diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 23070909a8..08d5644361 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -1 +1 @@ -.github/CODEOWNERS @SonarSource/quality-data-ml-squad +.github/CODEOWNERS @SonarSource/code-quality-core-languages-parsers-squad diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md deleted file mode 100644 index 4ae372795e..0000000000 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ /dev/null @@ -1,7 +0,0 @@ -Part of - diff --git a/.github/actions/ruling-diff-comment/action.yml b/.github/actions/ruling-diff-comment/action.yml new file mode 100644 index 0000000000..010e838ad2 --- /dev/null +++ b/.github/actions/ruling-diff-comment/action.yml @@ -0,0 +1,38 @@ +name: 'Ruling Diff Comment' +description: 'Posts a human-readable summary of ruling file changes on PRs' + +inputs: + pr-number: + description: 'Pull request number' + required: true + repository: + description: 'owner/repo' + required: true + base-sha: + description: 'Base commit SHA for diff' + required: true + head-sha: + description: 'Head commit SHA for diff' + required: true + +runs: + using: 'composite' + steps: + - name: Run unit tests + shell: bash + run: uv run --project "${{ github.action_path }}" python -m unittest discover -v -s "${{ github.action_path }}" -p "test_ruling_diff.py" + + - name: Generate and post ruling diff comment + shell: bash + env: + GH_TOKEN: ${{ env.GH_TOKEN }} + PR_NUMBER: ${{ inputs.pr-number }} + REPOSITORY: ${{ inputs.repository }} + BASE_SHA: ${{ inputs.base-sha }} + HEAD_SHA: ${{ inputs.head-sha }} + run: | + uv run --project "${{ github.action_path }}" python "${{ github.action_path }}/ruling_diff.py" \ + --pr-number "$PR_NUMBER" \ + --repository "$REPOSITORY" \ + --base-sha "$BASE_SHA" \ + --head-sha "$HEAD_SHA" diff --git a/.github/actions/ruling-diff-comment/pyproject.toml b/.github/actions/ruling-diff-comment/pyproject.toml new file mode 100644 index 0000000000..89b0ba6514 --- /dev/null +++ b/.github/actions/ruling-diff-comment/pyproject.toml @@ -0,0 +1,9 @@ +[project] +name = "ruling-diff-comment" +version = "0.1.0" +description = "GitHub Action helper for ruling diff comments" +requires-python = ">=3.10" +dependencies = [] + +[tool.uv] +package = false diff --git a/.github/actions/ruling-diff-comment/ruling_diff.py b/.github/actions/ruling-diff-comment/ruling_diff.py new file mode 100644 index 0000000000..f4468b8a93 --- /dev/null +++ b/.github/actions/ruling-diff-comment/ruling_diff.py @@ -0,0 +1,74 @@ +from __future__ import annotations + +import argparse +import logging +import os +import sys + +from ruling_diff_core import build_rule_diffs, format_comment +from ruling_diff_io import ( + GitHubActionIO, + get_changed_ruling_files, + post_or_update_comment, +) + + +def configure_logging() -> None: + level = logging.DEBUG if os.environ.get("RUNNER_DEBUG") else logging.INFO + logging.basicConfig(level=level, format="%(asctime)s %(levelname)s %(message)s") + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Generate and post ruling diff comment" + ) + parser.add_argument("--pr-number", required=True) + parser.add_argument("--repository", required=True) + parser.add_argument("--base-sha", required=True) + parser.add_argument("--head-sha", required=True) + args = parser.parse_args() + if "/" not in args.repository: + raise ValueError("--repository must be in owner/repo format") + return args + + +def has_required_context(args: argparse.Namespace) -> bool: + return bool( + args.pr_number.strip() and args.base_sha.strip() and args.head_sha.strip() + ) + + +def main() -> None: + configure_logging() + args = parse_args() + if not has_required_context(args): + logging.info("Missing pr/base/head arguments. Skipping ruling diff comment.") + return + + changed_files = get_changed_ruling_files(args.base_sha, args.head_sha) + if not changed_files: + logging.info("No changed ruling json files found. Nothing to do.") + return + + logging.info("Found %d changed ruling json files", len(changed_files)) + io = GitHubActionIO() + rule_diffs = build_rule_diffs( + changed_files, + args.base_sha, + args.head_sha, + io, + ) + if not rule_diffs: + logging.info("Changed files have no issue deltas. No comment will be posted.") + return + + comment = format_comment(rule_diffs) + post_or_update_comment(args.pr_number, args.repository, comment) + + +if __name__ == "__main__": + try: + main() + except Exception as exc: + logging.error("Failed to generate ruling diff comment: %s", exc) + sys.exit(1) diff --git a/.github/actions/ruling-diff-comment/ruling_diff_core.py b/.github/actions/ruling-diff-comment/ruling_diff_core.py new file mode 100644 index 0000000000..c8e633ea06 --- /dev/null +++ b/.github/actions/ruling-diff-comment/ruling_diff_core.py @@ -0,0 +1,41 @@ +from ruling_diff_core_lib.comment_rendering import format_comment +from ruling_diff_core_lib.models_and_constants import ( + COMMENT_MARKER, + COMMENT_SOFT_LIMIT, + EXPECTED_RULING_ROOT, + IssueDiff, + RuleDiff, + Snippet, +) +from ruling_diff_core_lib.ruling_diff_logic import ( + build_rule_diffs, + diff_ruling_jsons, + parse_ruling_path, + parse_ruling_relative_path, + parse_rule_filename, + strip_project_key, +) +from ruling_diff_core_lib.snippet_generation import ( + render_file_level_snippet, + render_line_snippet, + render_snippet, +) + +__all__ = [ + "COMMENT_MARKER", + "COMMENT_SOFT_LIMIT", + "EXPECTED_RULING_ROOT", + "IssueDiff", + "RuleDiff", + "Snippet", + "build_rule_diffs", + "diff_ruling_jsons", + "format_comment", + "parse_ruling_path", + "parse_ruling_relative_path", + "parse_rule_filename", + "render_file_level_snippet", + "render_line_snippet", + "render_snippet", + "strip_project_key", +] diff --git a/.github/actions/ruling-diff-comment/ruling_diff_core_lib/__init__.py b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/__init__.py new file mode 100644 index 0000000000..c8e633ea06 --- /dev/null +++ b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/__init__.py @@ -0,0 +1,41 @@ +from ruling_diff_core_lib.comment_rendering import format_comment +from ruling_diff_core_lib.models_and_constants import ( + COMMENT_MARKER, + COMMENT_SOFT_LIMIT, + EXPECTED_RULING_ROOT, + IssueDiff, + RuleDiff, + Snippet, +) +from ruling_diff_core_lib.ruling_diff_logic import ( + build_rule_diffs, + diff_ruling_jsons, + parse_ruling_path, + parse_ruling_relative_path, + parse_rule_filename, + strip_project_key, +) +from ruling_diff_core_lib.snippet_generation import ( + render_file_level_snippet, + render_line_snippet, + render_snippet, +) + +__all__ = [ + "COMMENT_MARKER", + "COMMENT_SOFT_LIMIT", + "EXPECTED_RULING_ROOT", + "IssueDiff", + "RuleDiff", + "Snippet", + "build_rule_diffs", + "diff_ruling_jsons", + "format_comment", + "parse_ruling_path", + "parse_ruling_relative_path", + "parse_rule_filename", + "render_file_level_snippet", + "render_line_snippet", + "render_snippet", + "strip_project_key", +] diff --git a/.github/actions/ruling-diff-comment/ruling_diff_core_lib/comment_rendering.py b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/comment_rendering.py new file mode 100644 index 0000000000..6eba3c5944 --- /dev/null +++ b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/comment_rendering.py @@ -0,0 +1,104 @@ +from __future__ import annotations + +from ruling_diff_core_lib.models_and_constants import ( + COMMENT_MARKER, + COMMENT_SOFT_LIMIT, + RuleDiff, + Snippet, +) + + +def format_comment( + rule_diffs: list[RuleDiff], soft_limit: int = COMMENT_SOFT_LIMIT +) -> str: + if not rule_diffs: + return "\n".join( + [ + COMMENT_MARKER, + "## Ruling Diff Summary", + "", + "No issue deltas detected." + ] + ) + comment = format_comment_header(rule_diffs) + return append_rule_sections_with_soft_limit(comment, rule_diffs, soft_limit) + + +def format_comment_header(rule_diffs: list[RuleDiff]) -> str: + added = sum(len(diff.added_lines) for rule in rule_diffs for diff in rule.file_diffs) + removed = sum( + len(diff.removed_lines) for rule in rule_diffs for diff in rule.file_diffs + ) + return "\n".join( + [ + COMMENT_MARKER, + "## Ruling Diff Summary", + "", + f"Detected changes in {len(rule_diffs)} rule files: {removed} issues removed, {added} issues added.", + "", + ] + ) + + +def append_rule_sections_with_soft_limit( + comment: str, rule_diffs: list[RuleDiff], soft_limit: int +) -> str: + sections = [format_rule_section(rule_diff) for rule_diff in rule_diffs] + accepted_sections: list[str] = [] + truncated_count = 0 + for index, section in enumerate(sections): + candidate = comment + "\n\n".join(accepted_sections + [section]) + if len(candidate) > soft_limit: + truncated_count = len(sections) - index + break + accepted_sections.append(section) + if accepted_sections: + comment += "\n\n".join(accepted_sections) + if truncated_count: + comment = append_truncation_notice(comment, truncated_count, bool(accepted_sections)) + return comment + + +def append_truncation_notice(comment: str, count: int, has_sections: bool) -> str: + separator = "\n\n" if has_sections else "" + return ( + comment + + separator + + f"... and {count} more rules with changes (diff too large to display fully)" + ) + + +def format_rule_section(rule_diff: RuleDiff) -> str: + lines = ["
", f"{format_rule_summary(rule_diff)}", ""] + if not rule_diff.snippets: + lines.append("No source snippets available for this rule.") + else: + for snippet in rule_diff.snippets: + lines.append(format_snippet_block(snippet)) + lines.append("") + lines.append("
") + return "\n".join(lines) + + +def format_rule_summary(rule_diff: RuleDiff) -> str: + removed = sum(len(diff.removed_lines) for diff in rule_diff.file_diffs) + added = sum(len(diff.added_lines) for diff in rule_diff.file_diffs) + summary_parts = [ + f"{rule_diff.rule_key} ({rule_diff.repo}) on {rule_diff.project}", + f"{removed} issues removed, {added} issues added", + ] + if rule_diff.is_new_file: + summary_parts.append("new ruling file") + if rule_diff.is_deleted_file: + summary_parts.append("deleted ruling file") + return " - ".join(summary_parts) + + +def format_snippet_block(snippet: Snippet) -> str: + return "\n".join([format_snippet_header(snippet), "```python", snippet.body, "```"]) + + +def format_snippet_header(snippet: Snippet) -> str: + label = "Added" if snippet.change_kind == "added" else "Removed" + location = "file-level" if snippet.line_number == 0 else f"line {snippet.line_number}" + return f"**{label}** `{snippet.file_path}` ({location})" diff --git a/.github/actions/ruling-diff-comment/ruling_diff_core_lib/models_and_constants.py b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/models_and_constants.py new file mode 100644 index 0000000000..d5e5339f5d --- /dev/null +++ b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/models_and_constants.py @@ -0,0 +1,71 @@ +from __future__ import annotations + +from dataclasses import dataclass +from typing import Protocol + +RulingJson = dict[str, list[int]] +OptionalRulingJson = RulingJson | None +SourceLines = list[str] +OptionalSourceLines = SourceLines | None +SourceCache = dict[tuple[str, str], OptionalSourceLines] + + +class RulingDiffIO(Protocol): + def load_json_at_ref(self, path: str, ref: str) -> OptionalRulingJson: + ... + + def load_text_at_ref(self, path: str, ref: str) -> str | None: + ... + + def resolve_source_path(self, project: str, file_path: str) -> str: + ... + +EXPECTED_RULING_ROOT = ( + "private/its-enterprise/ruling/src/test/resources/expected_ruling" +) +COMMENT_MARKER = "" +COMMENT_SOFT_LIMIT = 60000 +SNIPPET_CONTEXT = 5 +MAX_SNIPPETS_PER_FILE = 3 +MAX_SNIPPETS_PER_RULE = 15 + +PROJECT_SOURCE_OVERRIDES = { + "buildbot": "private/its-enterprise/sources_ruling/buildbot-0.8.6p1", + "buildbot-slave": "private/its-enterprise/sources_ruling/buildbot-slave-0.8.6p1", + "django": "private/its-enterprise/sources_ruling/django-2.2.3", + "django-cms": "private/its-enterprise/sources_ruling/django-cms-3.7.1", + "docker-compose": "private/its-enterprise/sources_ruling/docker-compose-1.24.1", + "mypy": "private/its-enterprise/sources_ruling/mypy-0.782", + "numpy": "private/its-enterprise/sources_ruling/numpy-1.16.4", + "tornado": "private/its-enterprise/sources_ruling/tornado-2.3", + "twisted": "private/its-enterprise/sources_ruling/twisted-12.1.0", + "sources_internal_ruling": "private/its-enterprise/sources_internal_ruling", + "namespace_basic": "private/its-enterprise/sources_internal_namespace_ruling/basic_namespace", + "namespace_mixed": "private/its-enterprise/sources_internal_namespace_ruling/mixed_namespace", +} + + +@dataclass(frozen=True) +class IssueDiff: + file_path: str + added_lines: list[int] + removed_lines: list[int] + + +@dataclass(frozen=True) +class Snippet: + file_path: str + line_number: int + change_kind: str + body: str + + +@dataclass(frozen=True) +class RuleDiff: + project: str + repo: str + rule_key: str + file_diffs: list[IssueDiff] + snippets: list[Snippet] + is_new_file: bool + is_deleted_file: bool diff --git a/.github/actions/ruling-diff-comment/ruling_diff_core_lib/ruling_diff_logic.py b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/ruling_diff_logic.py new file mode 100644 index 0000000000..e77ee245eb --- /dev/null +++ b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/ruling_diff_logic.py @@ -0,0 +1,146 @@ +from __future__ import annotations + +from collections import Counter +from pathlib import PurePosixPath + +from ruling_diff_core_lib.models_and_constants import ( + EXPECTED_RULING_ROOT, + IssueDiff, + OptionalRulingJson, + RulingDiffIO, + RuleDiff, + RulingJson, + SourceCache, + Snippet, +) +from ruling_diff_core_lib.snippet_generation import build_snippets_for_rule + + +def parse_ruling_path(path: str) -> tuple[str, str, str]: + prefix = f"{EXPECTED_RULING_ROOT}/" + if not path.startswith(prefix): + raise ValueError(f"Unexpected ruling path outside expected root: {path}") + relative_path = path[len(prefix) :] + project, filename = parse_ruling_relative_path(relative_path) + repository, rule_key = parse_rule_filename(filename) + return project, repository, rule_key + + +def parse_ruling_relative_path(relative_path: str) -> tuple[str, str]: + parts = PurePosixPath(relative_path).parts + if len(parts) != 2: + raise ValueError( + f"Expected '/-.json' path, got: {relative_path}" + ) + return parts[0], parts[1] + + +def parse_rule_filename(filename: str) -> tuple[str, str]: + if not filename.endswith(".json"): + raise ValueError(f"Expected json filename, got: {filename}") + basename = filename[:-5] + if "-" not in basename: + raise ValueError(f"Expected '-.json', got: {filename}") + repository, rule_key = basename.rsplit("-", 1) + if not repository: + raise ValueError(f"Missing repo in filename: {filename}") + if not rule_key: + raise ValueError(f"Missing rule key in filename: {filename}") + return repository, rule_key + + +def strip_project_key(key: str) -> str: + return key.split(":", 1)[1] if ":" in key else key + + +def diff_ruling_jsons( + old: OptionalRulingJson, new: OptionalRulingJson +) -> list[IssueDiff]: + old_map = old or {} + new_map = new or {} + return [ + issue_diff + for issue_diff in ( + diff_single_file_key(key, old_map, new_map) + for key in sorted(set(old_map) | set(new_map)) + ) + if issue_diff is not None + ] + + +def diff_single_file_key( + key: str, old_map: RulingJson, new_map: RulingJson +) -> IssueDiff | None: + old_counter = Counter(old_map.get(key, [])) + new_counter = Counter(new_map.get(key, [])) + added_lines: list[int] = expand_line_counter(new_counter - old_counter) + removed_lines: list[int] = expand_line_counter(old_counter - new_counter) + if not added_lines and not removed_lines: + return None + return IssueDiff( + file_path=strip_project_key(key), + added_lines=added_lines, + removed_lines=removed_lines, + ) + + +def expand_line_counter(counter: Counter[int]) -> list[int]: + line_numbers: list[int] = [] + for line_number in sorted(counter): + line_numbers.extend([line_number] * counter[line_number]) + return line_numbers + + +def build_rule_diffs( + changed_files: list[str], + base_sha: str, + head_sha: str, + io: RulingDiffIO, +) -> list[RuleDiff]: + source_cache: SourceCache = {} + diffs = [ + build_rule_diff_for_file( + path, + base_sha, + head_sha, + source_cache, + io, + ) + for path in sorted(changed_files) + ] + return sorted( + [rule_diff for rule_diff in diffs if rule_diff is not None], + key=lambda diff: (diff.project, diff.repo, diff.rule_key), + ) + + +def build_rule_diff_for_file( + path: str, + base_sha: str, + head_sha: str, + source_cache: SourceCache, + io: RulingDiffIO, +) -> RuleDiff | None: + project, repository, rule_key = parse_ruling_path(path) + old_json: OptionalRulingJson = io.load_json_at_ref(path, base_sha) + new_json: OptionalRulingJson = io.load_json_at_ref(path, head_sha) + file_diffs: list[IssueDiff] = diff_ruling_jsons(old_json, new_json) + if not file_diffs: + return None + snippets: list[Snippet] = build_snippets_for_rule( + project, + file_diffs, + source_cache, + base_sha, + head_sha, + io, + ) + return RuleDiff( + project=project, + repo=repository, + rule_key=rule_key, + file_diffs=file_diffs, + snippets=snippets, + is_new_file=old_json is None, + is_deleted_file=new_json is None, + ) diff --git a/.github/actions/ruling-diff-comment/ruling_diff_core_lib/snippet_generation.py b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/snippet_generation.py new file mode 100644 index 0000000000..40e3a1f829 --- /dev/null +++ b/.github/actions/ruling-diff-comment/ruling_diff_core_lib/snippet_generation.py @@ -0,0 +1,153 @@ +from __future__ import annotations + +from ruling_diff_core_lib.models_and_constants import ( + IssueDiff, + MAX_SNIPPETS_PER_FILE, + MAX_SNIPPETS_PER_RULE, + SNIPPET_CONTEXT, + OptionalSourceLines, + RulingDiffIO, + Snippet, + SourceCache, + SourceLines, +) + + +def unique_line_numbers_preserving_order(lines: list[int]) -> list[int]: + return list(dict.fromkeys(lines)) + + +def render_snippet( + lines: OptionalSourceLines, issue_line: int, context: int = SNIPPET_CONTEXT +) -> str: + if lines is None: + return "(source file not found at this revision)" + if issue_line == 0: + return render_file_level_snippet(lines, context) + return render_line_snippet(lines, issue_line, context) + + +def render_file_level_snippet(lines: SourceLines, context: int) -> str: + if not lines: + return ">>> FILE-LEVEL ISSUE\n(empty file)" + end = min(len(lines), 1 + (2 * context)) + content = [f" {index:>6} | {lines[index - 1]}" for index in range(1, end + 1)] + return "\n".join([">>> FILE-LEVEL ISSUE", *content]) + + +def render_line_snippet(lines: SourceLines, issue_line: int, context: int) -> str: + if not lines: + return f">>> ISSUE HERE (line {issue_line})\n(empty file)" + clamped_line = max(1, min(issue_line, len(lines))) + prefix = [] + if issue_line != clamped_line: + prefix.append( + f"(requested line {issue_line} not present, showing closest line {clamped_line})" + ) + body = render_line_window(lines, clamped_line, context) + return "\n".join(prefix + body) + + +def render_line_window(lines: SourceLines, center_line: int, context: int) -> list[str]: + start = max(1, center_line - context) + end = min(len(lines), center_line + context) + rendered: list[str] = [] + for number in range(start, end + 1): + marker = ">>>" if number == center_line else " " + rendered.append(f"{marker} {number:>6} | {lines[number - 1]}") + return rendered + + +def build_snippets_for_rule( + project: str, + file_diffs: list[IssueDiff], + source_cache: SourceCache, + base_sha: str, + head_sha: str, + io: RulingDiffIO, +) -> list[Snippet]: + snippets: list[Snippet] = [] + for file_diff in file_diffs: + snippets.extend( + collect_snippets_for_file( + project=project, + file_diff=file_diff, + source_cache=source_cache, + base_sha=base_sha, + head_sha=head_sha, + io=io, + ) + ) + if len(snippets) >= MAX_SNIPPETS_PER_RULE: + break + return snippets[:MAX_SNIPPETS_PER_RULE] + + +def collect_snippets_for_file( + *, + project: str, + file_diff: IssueDiff, + source_cache: SourceCache, + base_sha: str, + head_sha: str, + io: RulingDiffIO, +) -> list[Snippet]: + snippets: list[Snippet] = [] + for change_kind, lines in ( + ("removed", unique_line_numbers_preserving_order(file_diff.removed_lines)), + ("added", unique_line_numbers_preserving_order(file_diff.added_lines)), + ): + for line_number in lines[:MAX_SNIPPETS_PER_FILE]: + snippets.append( + create_issue_snippet( + project=project, + file_path=file_diff.file_path, + line_number=line_number, + change_kind=change_kind, + source_cache=source_cache, + base_sha=base_sha, + head_sha=head_sha, + io=io, + ) + ) + return snippets + + +def create_issue_snippet( + *, + project: str, + file_path: str, + line_number: int, + change_kind: str, + source_cache: SourceCache, + base_sha: str, + head_sha: str, + io: RulingDiffIO, +) -> Snippet: + ref = head_sha if change_kind == "added" else base_sha + source_path = io.resolve_source_path(project, file_path) + lines = load_source_lines_with_cache(source_cache, ref, source_path, io) + body = ( + f"(source file not found at this revision: {file_path})" + if lines is None + else render_snippet(lines, line_number) + ) + return Snippet( + file_path=file_path, + line_number=line_number, + change_kind=change_kind, + body=body, + ) + + +def load_source_lines_with_cache( + cache: SourceCache, + ref: str, + path: str, + io: RulingDiffIO, +) -> OptionalSourceLines: + key = (ref, path) + if key not in cache: + content = io.load_text_at_ref(path, ref) + cache[key] = None if content is None else content.splitlines() + return cache[key] diff --git a/.github/actions/ruling-diff-comment/ruling_diff_io.py b/.github/actions/ruling-diff-comment/ruling_diff_io.py new file mode 100644 index 0000000000..65b80f595f --- /dev/null +++ b/.github/actions/ruling-diff-comment/ruling_diff_io.py @@ -0,0 +1,332 @@ +from __future__ import annotations + +import json +import logging +import subprocess +from pathlib import Path + +from ruling_diff_core_lib.models_and_constants import ( + COMMENT_MARKER, + EXPECTED_RULING_ROOT, + PROJECT_SOURCE_OVERRIDES, +) + +RULING_SOURCES_SUBMODULE = "private/its-enterprise/sources_ruling" +SOURCES_INTERNAL_RULING_ROOT = "private/its-enterprise/sources_internal_ruling" +SOURCES_INTERNAL_NAMESPACE_RULING_ROOT = ( + "private/its-enterprise/sources_internal_namespace_ruling" +) + + +class CommandError(RuntimeError): + pass + + +class GitHubActionIO: + def load_json_at_ref(self, path: str, ref: str) -> dict[str, list[int]] | None: + return load_json_at_ref(path, ref) + + def load_text_at_ref(self, path: str, ref: str) -> str | None: + return load_text_at_ref(path, ref) + + def resolve_source_path(self, project: str, file_path: str) -> str: + if project == "project": + return self._resolve_project_source_path(file_path) + source_root = PROJECT_SOURCE_OVERRIDES.get( + project, f"{RULING_SOURCES_SUBMODULE}/{project}" + ) + return f"{source_root}/{file_path.lstrip('/')}" + + def _resolve_project_source_path(self, file_path: str) -> str: + clean_path = file_path.lstrip("/") + primary_candidate = f"{RULING_SOURCES_SUBMODULE}/{clean_path}" + candidates = [primary_candidate] + candidates.extend( + self._with_direct_children_prefixes(RULING_SOURCES_SUBMODULE, clean_path) + ) + candidates.append(f"{SOURCES_INTERNAL_RULING_ROOT}/{clean_path}") + candidates.append(f"{SOURCES_INTERNAL_NAMESPACE_RULING_ROOT}/{clean_path}") + candidates.extend( + self._with_direct_children_prefixes( + SOURCES_INTERNAL_NAMESPACE_RULING_ROOT, clean_path + ) + ) + for candidate in candidates: + if Path(candidate).is_file(): + return candidate + return primary_candidate + + def _with_direct_children_prefixes(self, root: str, file_path: str) -> list[str]: + root_path = Path(root) + if not root_path.is_dir(): + return [] + return [ + f"{root}/{child.name}/{file_path}" + for child in sorted(root_path.iterdir(), key=lambda path: path.name) + if child.is_dir() and not child.name.startswith(".") + ] + + +def run_command(command: list[str]) -> str: + result = subprocess.run(command, capture_output=True, text=True) + if result.returncode != 0: + raise CommandError( + format_command_failure( + command, result.stdout, result.stderr, result.returncode + ) + ) + return result.stdout + + +def format_command_failure( + command: list[str], stdout: str, stderr: str, returncode: int +) -> str: + return ( + f"Command failed with exit code {returncode}: {' '.join(command)}\n" + f"stdout: {stdout}\n" + f"stderr: {stderr}" + ) + + +def run_gh_json(command: list[str]) -> dict | list: + output = run_command(["gh", *command]) + try: + return json.loads(output) + except json.JSONDecodeError as exc: + raise CommandError(f"Could not parse JSON from gh output: {exc}") from exc + + +def run_gh_paginated_items(endpoint: str) -> list[dict]: + output = run_command(["gh", "api", "--paginate", endpoint]) + docs = parse_json_documents(output) + items: list[dict] = [] + for doc in docs: + if not isinstance(doc, list): + raise CommandError("Unexpected response type while listing paginated items") + for item in doc: + if isinstance(item, dict): + items.append(item) + return items + + +def parse_json_documents(content: str) -> list[object]: + decoder = json.JSONDecoder() + index = 0 + documents: list[object] = [] + while index < len(content): + while index < len(content) and content[index].isspace(): + index += 1 + if index >= len(content): + break + document, next_index = decoder.raw_decode(content, index) + documents.append(document) + index = next_index + return documents + + +def get_changed_ruling_files(base_sha: str, head_sha: str) -> list[str]: + output = run_command( + [ + "git", + "diff", + "--name-only", + f"{base_sha}...{head_sha}", + "--", + f"{EXPECTED_RULING_ROOT}/", + ] + ) + changed = [ + path + for path in (line.strip() for line in output.splitlines()) + if is_ruling_json(path) + ] + return sorted(set(changed)) + + +def is_ruling_json(path: str) -> bool: + return ( + bool(path) + and path.endswith(".json") + and path.startswith(f"{EXPECTED_RULING_ROOT}/") + ) + + +def _is_missing_at_ref(stderr: str) -> bool: + return any( + marker in stderr + for marker in ("exists on disk, but not in", "does not exist in", "path '") + ) + + +def load_json_at_ref(path: str, ref: str) -> dict[str, list[int]] | None: + result = subprocess.run( + ["git", "show", f"{ref}:{path}"], capture_output=True, text=True + ) + if result.returncode != 0: + if _is_missing_at_ref(result.stderr): + return None + raise CommandError( + f"Failed to read file at ref: git show {ref}:{path}\nstdout: {result.stdout}\nstderr: {result.stderr}" + ) + return parse_ruling_json(result.stdout, path, ref) + + +def parse_ruling_json(content: str, path: str, ref: str) -> dict[str, list[int]]: + try: + data = json.loads(content) + except json.JSONDecodeError as exc: + raise ValueError(f"Malformed JSON in {path} at {ref}: {exc}") from exc + if not isinstance(data, dict): + raise ValueError(f"Ruling file {path} at {ref} must be a JSON object") + return normalize_ruling_json(data, path, ref) + + +def normalize_ruling_json(data: dict, path: str, ref: str) -> dict[str, list[int]]: + normalized: dict[str, list[int]] = {} + for key, value in data.items(): + if not isinstance(key, str): + raise ValueError(f"Ruling file {path} at {ref} has non-string key") + if not isinstance(value, list) or not all(isinstance(v, int) for v in value): + raise ValueError( + f"Ruling file {path} at {ref} has non-integer line list for key {key}" + ) + normalized[key] = value + return normalized + + +def load_text_at_ref(path: str, ref: str) -> str | None: + if is_ruling_source_path(path): + return load_submodule_text_at_ref(path, ref) + + result = subprocess.run( + ["git", "show", f"{ref}:{path}"], capture_output=True, text=True + ) + if result.returncode == 0: + return result.stdout + if _is_missing_at_ref(result.stderr): + return load_text_with_workspace_fallback(path, ref) + raise CommandError( + f"Failed to read source file at ref: git show {ref}:{path}\nstdout: {result.stdout}\nstderr: {result.stderr}" + ) + + +def is_ruling_source_path(path: str) -> bool: + return path.startswith(f"{RULING_SOURCES_SUBMODULE}/") + + +def load_submodule_text_at_ref(path: str, ref: str) -> str | None: + submodule_commit = get_submodule_commit_for_ref(ref) + if submodule_commit is None: + return load_text_with_workspace_fallback(path, ref) + + submodule_relative_path = path[len(f"{RULING_SOURCES_SUBMODULE}/") :] + content = read_submodule_file_at_commit(submodule_commit, submodule_relative_path) + if content is not None: + return content + + fetch_submodule_commit(submodule_commit) + content = read_submodule_file_at_commit(submodule_commit, submodule_relative_path) + if content is not None: + return content + + logging.warning( + "Source file '%s' not found in submodule commit %s for %s", + path, + submodule_commit, + ref, + ) + return load_text_with_workspace_fallback(path, ref) + + +def get_submodule_commit_for_ref(ref: str) -> str | None: + result = subprocess.run( + ["git", "rev-parse", f"{ref}:{RULING_SOURCES_SUBMODULE}"], + capture_output=True, + text=True, + ) + if result.returncode != 0: + logging.warning( + "Could not resolve ruling sources submodule commit for %s: %s", + ref, + result.stderr.strip(), + ) + return None + return result.stdout.strip() + + +def read_submodule_file_at_commit(commit: str, relative_path: str) -> str | None: + result = subprocess.run( + ["git", "-C", RULING_SOURCES_SUBMODULE, "show", f"{commit}:{relative_path}"], + capture_output=True, + text=True, + ) + if result.returncode == 0: + return result.stdout + return None + + +def fetch_submodule_commit(commit: str) -> None: + subprocess.run( + [ + "git", + "-C", + RULING_SOURCES_SUBMODULE, + "fetch", + "--depth", + "1", + "origin", + commit, + ], + capture_output=True, + text=True, + ) + + +def load_text_with_workspace_fallback(path: str, ref: str) -> str | None: + workspace_content = load_workspace_text(path) + if workspace_content is None: + logging.warning("Source file '%s' not found at %s", path, ref) + return None + logging.warning("Source file '%s' not found at %s, using workspace copy", path, ref) + return workspace_content + + +def load_workspace_text(path: str) -> str | None: + workspace_path = Path(path) + if not workspace_path.is_file(): + return None + return workspace_path.read_text(encoding="utf-8") + + +def get_existing_comment_id(pr_number: str, repository: str) -> str | None: + comments = run_gh_paginated_items( + f"repos/{repository}/issues/{pr_number}/comments?per_page=100" + ) + for comment in comments: + if COMMENT_MARKER in comment.get("body", ""): + return str(comment["id"]) + return None + + +def post_or_update_comment(pr_number: str, repository: str, body: str) -> None: + comment_id = get_existing_comment_id(pr_number, repository) + if comment_id is None: + logging.info("Posting new ruling diff comment on PR #%s", pr_number) + run_command( + ["gh", "pr", "comment", pr_number, "--repo", repository, "--body", body] + ) + return + logging.info( + "Updating existing ruling diff comment %s on PR #%s", comment_id, pr_number + ) + run_command( + [ + "gh", + "api", + "--method", + "PATCH", + f"repos/{repository}/issues/comments/{comment_id}", + "-f", + f"body={body}", + ] + ) diff --git a/.github/actions/ruling-diff-comment/test_ruling_diff.py b/.github/actions/ruling-diff-comment/test_ruling_diff.py new file mode 100644 index 0000000000..5b7ed077bd --- /dev/null +++ b/.github/actions/ruling-diff-comment/test_ruling_diff.py @@ -0,0 +1,508 @@ +import pathlib +import subprocess +import sys +import tempfile +import unittest +from unittest.mock import patch + + +MODULE_DIR = pathlib.Path(__file__).parent +if str(MODULE_DIR) not in sys.path: + sys.path.insert(0, str(MODULE_DIR)) + +import ruling_diff_core as core +import ruling_diff_io as io + + +IssueDiff = core.IssueDiff +RuleDiff = core.RuleDiff +Snippet = core.Snippet + + +class FakeRulingDiffIO: + def __init__( + self, + json_by_ref_path: dict[tuple[str, str], dict[str, list[int]] | None], + text_by_ref_path: dict[tuple[str, str], str | None], + ) -> None: + self.json_by_ref_path = json_by_ref_path + self.text_by_ref_path = text_by_ref_path + self.load_json_calls: list[tuple[str, str]] = [] + self.load_text_calls: list[tuple[str, str]] = [] + self.resolve_calls: list[tuple[str, str]] = [] + + def load_json_at_ref(self, path: str, ref: str) -> dict[str, list[int]] | None: + self.load_json_calls.append((path, ref)) + return self.json_by_ref_path.get((path, ref)) + + def load_text_at_ref(self, path: str, ref: str) -> str | None: + self.load_text_calls.append((path, ref)) + return self.text_by_ref_path.get((path, ref)) + + def resolve_source_path(self, project: str, file_path: str) -> str: + self.resolve_calls.append((project, file_path)) + return f"sources/{project}/{file_path.lstrip('/')}" + + +class ParsePathTest(unittest.TestCase): + def test_parse_ruling_path(self) -> None: + path = "private/its-enterprise/ruling/src/test/resources/expected_ruling/airflow/python-S1066.json" + self.assertEqual(("airflow", "python", "S1066"), core.parse_ruling_path(path)) + + def test_parse_ruling_path_with_pythonenterprise(self) -> None: + path = "private/its-enterprise/ruling/src/test/resources/expected_ruling/specific-rules/pythonenterprise-S7471.json" + self.assertEqual( + ("specific-rules", "pythonenterprise", "S7471"), + core.parse_ruling_path(path), + ) + + def test_parse_ruling_path_with_legacy_key(self) -> None: + path = "private/its-enterprise/ruling/src/test/resources/expected_ruling/scikit-learn/python-LineLength.json" + self.assertEqual( + ("scikit-learn", "python", "LineLength"), + core.parse_ruling_path(path), + ) + + def test_parse_rule_filename_rejects_empty_rule_key(self) -> None: + with self.assertRaises(ValueError): + core.parse_rule_filename("python-.json") + + def test_parse_rule_filename_rejects_empty_repository(self) -> None: + with self.assertRaises(ValueError): + core.parse_rule_filename("-S1066.json") + + +class DiffLogicTest(unittest.TestCase): + def test_diff_ruling_jsons_added_issues(self) -> None: + diffs = core.diff_ruling_jsons({"proj:a.py": [1, 2]}, {"proj:a.py": [1, 2, 3]}) + self.assertEqual(1, len(diffs)) + self.assertEqual("a.py", diffs[0].file_path) + self.assertEqual([3], diffs[0].added_lines) + + def test_diff_ruling_jsons_removed_issues(self) -> None: + diffs = core.diff_ruling_jsons({"proj:a.py": [1, 2, 3]}, {"proj:a.py": [1]}) + self.assertEqual([2, 3], diffs[0].removed_lines) + + def test_diff_ruling_jsons_new_file_entry(self) -> None: + diffs = core.diff_ruling_jsons( + {"proj:a.py": [1]}, + {"proj:a.py": [1], "proj:b.py": [5]}, + ) + self.assertEqual("b.py", diffs[0].file_path) + self.assertEqual([5], diffs[0].added_lines) + + def test_diff_ruling_jsons_removed_file_entry(self) -> None: + diffs = core.diff_ruling_jsons( + {"proj:a.py": [1], "proj:b.py": [5]}, + {"proj:a.py": [1]}, + ) + self.assertEqual("b.py", diffs[0].file_path) + self.assertEqual([5], diffs[0].removed_lines) + + def test_diff_ruling_jsons_new_ruling_file(self) -> None: + diffs = core.diff_ruling_jsons(None, {"proj:a.py": [10]}) + self.assertEqual([10], diffs[0].added_lines) + + def test_diff_ruling_jsons_deleted_ruling_file(self) -> None: + diffs = core.diff_ruling_jsons({"proj:a.py": [10]}, None) + self.assertEqual([10], diffs[0].removed_lines) + + def test_diff_ruling_jsons_no_changes(self) -> None: + self.assertEqual( + [], + core.diff_ruling_jsons( + {"proj:a.py": [10], "proj:b.py": [11, 12]}, + {"proj:a.py": [10], "proj:b.py": [11, 12]}, + ), + ) + + def test_duplicate_line_numbers_preserved(self) -> None: + diffs = core.diff_ruling_jsons({"proj:a.py": [297]}, {"proj:a.py": [297, 297]}) + self.assertEqual([297], diffs[0].added_lines) + + +class FormattingTest(unittest.TestCase): + def test_format_comment_single_rule(self) -> None: + rule_diff = RuleDiff( + project="airflow", + repo="python", + rule_key="S107", + file_diffs=[IssueDiff("airflow/hooks/a.py", [10, 11], [8])], + snippets=[ + Snippet( + file_path="airflow/hooks/a.py", + line_number=10, + change_kind="added", + body=">>> 10 | x = 1", + ) + ], + is_new_file=False, + is_deleted_file=False, + ) + comment = core.format_comment([rule_diff]) + self.assertIn("## Ruling Diff Summary", comment) + self.assertIn("
", comment) + self.assertIn("**Added** `airflow/hooks/a.py` (line 10)", comment) + self.assertIn(">>> 10 | x = 1", comment) + self.assertIn("```python", comment) + + def test_format_comment_multiple_rules(self) -> None: + rule_diffs = [ + RuleDiff( + project="airflow", + repo="python", + rule_key="S107", + file_diffs=[IssueDiff("airflow/hooks/a.py", [10], [])], + snippets=[ + Snippet("airflow/hooks/a.py", 10, "added", ">>> 10 | return 1") + ], + is_new_file=False, + is_deleted_file=False, + ), + RuleDiff( + project="django", + repo="python", + rule_key="S3699", + file_diffs=[IssueDiff("django/core/b.py", [20], [15])], + snippets=[ + Snippet( + "django/core/b.py", 15, "removed", ">>> 15 | return None" + ) + ], + is_new_file=False, + is_deleted_file=False, + ), + ] + comment = core.format_comment(rule_diffs) + self.assertIn("Detected changes in 2 rule files", comment) + self.assertIn("S107", comment) + self.assertIn("S3699", comment) + + def test_format_comment_respects_collapse(self) -> None: + rule_diff = RuleDiff( + project="airflow", + repo="python", + rule_key="S107", + file_diffs=[IssueDiff("airflow/hooks/a.py", [10], [])], + snippets=[ + Snippet("airflow/hooks/a.py", 10, "added", ">>> 10 | return 1") + ], + is_new_file=False, + is_deleted_file=False, + ) + comment = core.format_comment([rule_diff]) + self.assertIn("
", comment) + self.assertIn("
", comment) + + def test_strip_project_key_from_path(self) -> None: + self.assertEqual( + "airflow/foo.py", core.strip_project_key("airflow:airflow/foo.py") + ) + + def test_line_zero_displayed_as_file_level(self) -> None: + rule_diff = RuleDiff( + project="specific-rules", + repo="python", + rule_key="S1451", + file_diffs=[IssueDiff("S1716.py", [0], [0])], + snippets=[Snippet("S1716.py", 0, "added", ">>> FILE-LEVEL ISSUE")], + is_new_file=False, + is_deleted_file=False, + ) + comment = core.format_comment([rule_diff]) + self.assertIn("file-level", comment) + self.assertIn(">>> FILE-LEVEL ISSUE", comment) + + def test_format_comment_truncates_when_limit_reached(self) -> None: + rule_diffs = [ + RuleDiff( + project=f"project-{index}", + repo="python", + rule_key=f"S{1000 + index}", + file_diffs=[IssueDiff("a.py", [1], [2])], + snippets=[ + Snippet( + "a.py", 1, "added", "\n".join([f"line {i}" for i in range(50)]) + ) + ], + is_new_file=False, + is_deleted_file=False, + ) + for index in range(5) + ] + comment = core.format_comment(rule_diffs, soft_limit=500) + self.assertIn("diff too large to display fully", comment) + + +class SnippetRenderingTest(unittest.TestCase): + def test_render_line_snippet_uses_plus_minus_five_lines(self) -> None: + lines = [f"line {i}" for i in range(1, 21)] + rendered = core.render_line_snippet(lines, issue_line=10, context=5) + self.assertIn(" 5 | line 5", rendered) + self.assertIn(">>> 10 | line 10", rendered) + self.assertIn(" 15 | line 15", rendered) + + def test_render_line_snippet_handles_out_of_range_line(self) -> None: + rendered = core.render_line_snippet(["alpha", "beta"], issue_line=99, context=5) + self.assertIn("requested line 99 not present", rendered) + self.assertIn(">>> 2 | beta", rendered) + + def test_render_file_level_snippet_marker(self) -> None: + rendered = core.render_file_level_snippet(["a", "b", "c"], context=5) + self.assertIn(">>> FILE-LEVEL ISSUE", rendered) + + def test_render_snippet_missing_source_placeholder(self) -> None: + rendered = core.render_snippet(None, issue_line=12, context=5) + self.assertEqual("(source file not found at this revision)", rendered) + + +class BuildRuleDiffsWithIOTest(unittest.TestCase): + def test_build_rule_diffs_uses_io_object_and_respects_refs(self) -> None: + changed_file = ( + "private/its-enterprise/ruling/src/test/resources/expected_ruling/" + "airflow/python-S107.json" + ) + io_impl = FakeRulingDiffIO( + json_by_ref_path={ + (changed_file, "base-sha"): {"airflow:a.py": [2]}, + (changed_file, "head-sha"): {"airflow:a.py": [2, 7]}, + }, + text_by_ref_path={ + ("sources/airflow/a.py", "head-sha"): "\n".join( + [f"line {index}" for index in range(1, 12)] + ), + }, + ) + + diffs = core.build_rule_diffs([changed_file], "base-sha", "head-sha", io_impl) + + self.assertEqual(1, len(diffs)) + self.assertEqual("airflow", diffs[0].project) + self.assertEqual("python", diffs[0].repo) + self.assertEqual("S107", diffs[0].rule_key) + self.assertEqual([7], diffs[0].file_diffs[0].added_lines) + self.assertEqual([], diffs[0].file_diffs[0].removed_lines) + self.assertIn((changed_file, "base-sha"), io_impl.load_json_calls) + self.assertIn((changed_file, "head-sha"), io_impl.load_json_calls) + self.assertEqual([("airflow", "a.py")], io_impl.resolve_calls) + self.assertEqual([("sources/airflow/a.py", "head-sha")], io_impl.load_text_calls) + + def test_build_rule_diffs_caches_source_loads_per_ref_and_path(self) -> None: + changed_file = ( + "private/its-enterprise/ruling/src/test/resources/expected_ruling/" + "airflow/python-S107.json" + ) + io_impl = FakeRulingDiffIO( + json_by_ref_path={ + (changed_file, "base-sha"): {"airflow:a.py": [1]}, + (changed_file, "head-sha"): {"airflow:a.py": [2, 2]}, + }, + text_by_ref_path={ + ("sources/airflow/a.py", "base-sha"): "base\ncontent\n", + ("sources/airflow/a.py", "head-sha"): "head\ncontent\n", + }, + ) + + core.build_rule_diffs([changed_file], "base-sha", "head-sha", io_impl) + + self.assertEqual(1, io_impl.load_text_calls.count(("sources/airflow/a.py", "base-sha"))) + self.assertEqual(1, io_impl.load_text_calls.count(("sources/airflow/a.py", "head-sha"))) + + def test_build_rule_diffs_missing_source_produces_placeholder_snippet(self) -> None: + changed_file = ( + "private/its-enterprise/ruling/src/test/resources/expected_ruling/" + "airflow/python-S107.json" + ) + io_impl = FakeRulingDiffIO( + json_by_ref_path={ + (changed_file, "base-sha"): {"airflow:a.py": [1]}, + (changed_file, "head-sha"): {"airflow:a.py": [1, 3]}, + }, + text_by_ref_path={("sources/airflow/a.py", "head-sha"): None}, + ) + + diffs = core.build_rule_diffs([changed_file], "base-sha", "head-sha", io_impl) + + self.assertEqual(1, len(diffs[0].snippets)) + self.assertEqual( + "(source file not found at this revision: a.py)", + diffs[0].snippets[0].body, + ) + + +class SourceLoadingTest(unittest.TestCase): + @patch("ruling_diff_io.subprocess.run") + def test_load_text_at_ref_reads_from_submodule_commit(self, mocked_run) -> None: + mocked_run.side_effect = [ + subprocess.CompletedProcess( + args=["git", "rev-parse"], + returncode=0, + stdout="subsha123\n", + stderr="", + ), + subprocess.CompletedProcess( + args=["git", "-C", "sources", "show"], + returncode=0, + stdout="print('from submodule')\n", + stderr="", + ), + ] + + content = io.load_text_at_ref( + "private/its-enterprise/sources_ruling/project/foo.py", "deadbeef" + ) + + self.assertEqual("print('from submodule')\n", content) + + @patch("ruling_diff_io.subprocess.run") + def test_load_text_at_ref_falls_back_to_workspace_copy_with_warning( + self, mocked_run + ) -> None: + mocked_run.return_value = subprocess.CompletedProcess( + args=["git"], + returncode=128, + stdout="", + stderr="fatal: path 'private/its-enterprise/sources_ruling/foo.py' exists on disk, but not in 'deadbeef'", + ) + with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False) as tmp: + tmp.write("print('from workspace')\n") + tmp_path = tmp.name + try: + with self.assertLogs(level="WARNING") as logs: + content = io.load_text_at_ref(tmp_path, "deadbeef") + self.assertEqual("print('from workspace')\n", content) + self.assertTrue(any("using workspace copy" in log for log in logs.output)) + finally: + pathlib.Path(tmp_path).unlink(missing_ok=True) + + @patch("ruling_diff_io.subprocess.run") + def test_load_text_at_ref_warns_when_source_missing(self, mocked_run) -> None: + mocked_run.return_value = subprocess.CompletedProcess( + args=["git"], + returncode=128, + stdout="", + stderr="fatal: path 'missing.py' exists on disk, but not in 'deadbeef'", + ) + with self.assertLogs(level="WARNING") as logs: + content = io.load_text_at_ref("missing.py", "deadbeef") + self.assertIsNone(content) + self.assertTrue(any("not found at deadbeef" in log for log in logs.output)) + + +class GitHubCommentLookupTest(unittest.TestCase): + @patch("ruling_diff_io.run_command") + def test_get_existing_comment_id_reads_all_pages(self, mocked_run_command) -> None: + mocked_run_command.return_value = ( + '[{"id": 1, "body": "first"}]\n' + '[{"id": 2, "body": "text "}]\n' + ) + + comment_id = io.get_existing_comment_id( + "895", "SonarSource/sonar-python-enterprise" + ) + + self.assertEqual("2", comment_id) + + def test_parse_json_documents_handles_multiple_arrays(self) -> None: + documents = io.parse_json_documents('[{"a":1}]\n[{"b":2}]') + self.assertEqual(2, len(documents)) + + +class GitHubActionIOTest(unittest.TestCase): + def test_resolve_source_path_for_project_rulings_uses_path_directly(self) -> None: + io_impl = io.GitHubActionIO() + self.assertEqual( + "private/its-enterprise/sources_ruling/biopython/Bio/Nexus/Nexus.py", + io_impl.resolve_source_path("project", "biopython/Bio/Nexus/Nexus.py"), + ) + + def test_resolve_source_path_for_project_rulings_falls_back_to_sources_child(self) -> None: + io_impl = io.GitHubActionIO() + self.assertEqual( + "private/its-enterprise/sources_ruling/specific-rules/S1716.py", + io_impl.resolve_source_path("project", "S1716.py"), + ) + + def test_resolve_source_path_for_project_rulings_falls_back_to_sources_internal(self) -> None: + io_impl = io.GitHubActionIO() + with tempfile.TemporaryDirectory() as tmp_dir: + sources_ruling = f"{tmp_dir}/sources_ruling" + sources_internal = f"{tmp_dir}/sources_internal_ruling" + sources_namespace = f"{tmp_dir}/sources_internal_namespace_ruling" + pathlib.Path(sources_ruling).mkdir(parents=True, exist_ok=True) + pathlib.Path(sources_internal).mkdir(parents=True, exist_ok=True) + pathlib.Path(sources_namespace).mkdir(parents=True, exist_ok=True) + target = f"{sources_internal}/foo.py" + pathlib.Path(target).write_text("x\n", encoding="utf-8") + with ( + patch.object(io, "RULING_SOURCES_SUBMODULE", sources_ruling), + patch.object(io, "SOURCES_INTERNAL_RULING_ROOT", sources_internal), + patch.object( + io, + "SOURCES_INTERNAL_NAMESPACE_RULING_ROOT", + sources_namespace, + ), + ): + self.assertEqual(target, io_impl.resolve_source_path("project", "foo.py")) + + def test_resolve_source_path_for_project_rulings_falls_back_to_namespace_child(self) -> None: + io_impl = io.GitHubActionIO() + with tempfile.TemporaryDirectory() as tmp_dir: + sources_ruling = f"{tmp_dir}/sources_ruling" + sources_internal = f"{tmp_dir}/sources_internal_ruling" + sources_namespace = f"{tmp_dir}/sources_internal_namespace_ruling" + namespace_child = f"{sources_namespace}/basic_namespace" + pathlib.Path(sources_ruling).mkdir(parents=True, exist_ok=True) + pathlib.Path(sources_internal).mkdir(parents=True, exist_ok=True) + pathlib.Path(namespace_child).mkdir(parents=True, exist_ok=True) + target = f"{namespace_child}/foo.py" + pathlib.Path(target).write_text("x\n", encoding="utf-8") + with ( + patch.object(io, "RULING_SOURCES_SUBMODULE", sources_ruling), + patch.object(io, "SOURCES_INTERNAL_RULING_ROOT", sources_internal), + patch.object( + io, + "SOURCES_INTERNAL_NAMESPACE_RULING_ROOT", + sources_namespace, + ), + ): + self.assertEqual(target, io_impl.resolve_source_path("project", "foo.py")) + + def test_resolve_source_path_for_project_rulings_returns_primary_on_miss(self) -> None: + io_impl = io.GitHubActionIO() + with tempfile.TemporaryDirectory() as tmp_dir: + sources_ruling = f"{tmp_dir}/sources_ruling" + sources_internal = f"{tmp_dir}/sources_internal_ruling" + sources_namespace = f"{tmp_dir}/sources_internal_namespace_ruling" + pathlib.Path(sources_ruling).mkdir(parents=True, exist_ok=True) + pathlib.Path(sources_internal).mkdir(parents=True, exist_ok=True) + pathlib.Path(sources_namespace).mkdir(parents=True, exist_ok=True) + primary = f"{sources_ruling}/missing.py" + with ( + patch.object(io, "RULING_SOURCES_SUBMODULE", sources_ruling), + patch.object(io, "SOURCES_INTERNAL_RULING_ROOT", sources_internal), + patch.object( + io, + "SOURCES_INTERNAL_NAMESPACE_RULING_ROOT", + sources_namespace, + ), + ): + self.assertEqual(primary, io_impl.resolve_source_path("project", "missing.py")) + + def test_resolve_source_path_uses_project_overrides(self) -> None: + io_impl = io.GitHubActionIO() + self.assertEqual( + "private/its-enterprise/sources_ruling/mypy-0.782/pkg/file.py", + io_impl.resolve_source_path("mypy", "pkg/file.py"), + ) + + def test_resolve_source_path_uses_default_project_root(self) -> None: + io_impl = io.GitHubActionIO() + self.assertEqual( + "private/its-enterprise/sources_ruling/custom-project/pkg/file.py", + io_impl.resolve_source_path("custom-project", "/pkg/file.py"), + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/.github/actions/ruling-diff-comment/uv.lock b/.github/actions/ruling-diff-comment/uv.lock new file mode 100644 index 0000000000..a3e2f30753 --- /dev/null +++ b/.github/actions/ruling-diff-comment/uv.lock @@ -0,0 +1,8 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" + +[[package]] +name = "ruling-diff-comment" +version = "0.1.0" +source = { virtual = "." } diff --git a/.github/actions/setup-orchestrator-cache/action.yml b/.github/actions/setup-orchestrator-cache/action.yml index b937f3e770..8a9e92e445 100644 --- a/.github/actions/setup-orchestrator-cache/action.yml +++ b/.github/actions/setup-orchestrator-cache/action.yml @@ -12,15 +12,17 @@ runs: - name: Calculate orchestrator cache key id: set-paths shell: bash + env: + SQ_VERSION: ${{ inputs.sq-version }} run: | # Get current month for cache rotation CURRENT_MONTH=$(date +"%B") - CACHE_KEY="orchestrator-${{ github.workflow }}-${{ inputs.sq-version }}-${CURRENT_MONTH}" + CACHE_KEY="orchestrator-${{ github.workflow }}-${SQ_VERSION}-${CURRENT_MONTH}" echo "cache-key=${CACHE_KEY}" >> $GITHUB_OUTPUT - name: Setup orchestrator cache - uses: SonarSource/ci-github-actions/cache@v1 + uses: SonarSource/gh-action_cache@v1 with: path: "~/.sonar/orchestrator/" key: "${{ steps.set-paths.outputs.cache-key }}" diff --git a/.github/instructions/rules-implementation.instructions.md b/.github/instructions/rules-implementation.instructions.md index 9666d1bab4..6340de151d 100644 --- a/.github/instructions/rules-implementation.instructions.md +++ b/.github/instructions/rules-implementation.instructions.md @@ -1,67 +1,10 @@ --- applyTo: "**/*checks*/**/*.java" --- -Here is some information about basic rule implementation: +# Rule implementation -- When implementing a new rule, the rule has to be added to [OpenSourceCheckList.java](../../python-checks/src/main/java/org/sonar/python/checks/OpenSourceCheckList.java). -- The class name ends in `Check`, for example `SleepZeroInAsyncCheck` -- Annotate the class with @Rule(key = "YourRuleKey"): -Replace "YourRuleKey" with a unique identifier for your rule (e.g., "S1234"). -- Always start out by having the rule extend `PythonSubscriptionCheck` as a first step -- Override the initialize(Context context) method: - This method is called once when the analysis starts. - Use context.registerSyntaxNodeConsumer(Kind.YOUR_TARGET_KIND, this::yourCheckMethod) to register a callback method for specific Python Abstract Syntax Tree (AST) node kinds you want to inspect. - Kind.YOUR_TARGET_KIND refers to the type of Python code structure you're interested in (e.g., Kind.CALL_EXPR for function calls, Kind.FUNCTION_DEF for function definitions, Kind.IF_STMT for if statements, etc.). - Make sure to use a Kind that exists in the Enum. -this::yourCheckMethod is a method reference to the method in your rule class that will be called when a node of the specified Kind is encountered. -- Implement your check method(s) (e.g., yourCheckMethod(SubscriptionContext context)): - This method will be called for each AST node of the Kind you registered in initialize. - Get the current AST node being visited using context.syntaxNode(). You'll likely need to cast it to its specific type (e.g., (CallExpression) context.syntaxNode()). - Implement the logic to analyze the AST node and its properties. - You can use TreeUtils for helper functions to navigate or inspect the AST (e.g., TreeUtils.firstAncestorOfKind(...), TreeUtils.nthArgumentOrKeyword(...)). - If you need to perform type checking: - You can initialize a TypeCheckMap in a method registered for Kind.FILE_INPUT (as seen with initializeTypeCheckMap in the example). - Use context.typeChecker().typeCheckBuilder() to define type checks (e.g., checking for a fully qualified name like isTypeWithFqn("module.submodule.function")). - Always prefer using the type checkers instead fully qualified names on the symbol -- Report issues: - If your rule's conditions are met and an issue should be raised, use context.addIssue(treeNode, message). - treeNode is the AST node to which the issue should be attached. - message is the description of the issue. - You can add secondary locations to an issue using issue.secondary(anotherTreeNode, secondaryMessage). -- Define message strings: - Use constants for messages (e.g., private static final String MESSAGE = "Your informative message here."). - Use String.format() if your messages need to include dynamic parts. -- (Optional) Create helper records or classes: - For more complex logic or to hold state/configuration related to specific checks (like MessageHolder in the example), you can define inner records or classes. +Do **not** follow outdated guidance that may appear elsewhere. The single source of truth is: -Commonly Used APIs and Utilities for Rule Implementation -- TreeUtils (org.sonar.python.tree.TreeUtils): - firstAncestorOfKind(tree, Kind...): Find the first ancestor node of a given kind. - firstAncestor(tree, Predicate): Find the first ancestor matching a predicate. - hasDescendant(tree, Predicate): Check if a tree has a descendant matching a predicate. - getSymbolFromTree(tree): Get the symbol associated with a tree node, if any. - getClassSymbolFromDef(classDef), getFunctionSymbolFromDef(functionDef): Get class/function symbol from definition node. - nthArgumentOrKeyword(int pos, String keyword, List): Get the nth or keyword argument from a call. Also has an Optional variant - argumentByKeyword(String keyword, List): Get argument by keyword. - isBooleanLiteral(tree): Check if a tree is a boolean literal. - toOptionalInstanceOf(Class, tree), toStreamInstanceOfMapper(Class): Safe casting and mapping for tree nodes. Useful for Optionals and avoiding nulls. - firstChild(tree, Predicate): Find the first child matching a predicate. -- Type Checking: - TypeCheckMap and TypeCheckBuilder (org.sonar.python.types.v2): Used to map type checks to actions or data, e.g., for matching function calls by type. - context.typeChecker().typeCheckBuilder().isTypeWithFqn("..."), isTypeOrInstanceWithName("..."), etc.: Build type checks for use in rules. -- SubscriptionContext (org.sonar.plugins.python.api.SubscriptionContext): - syntaxNode(): Get the current AST node being visited. - addIssue(tree, message): Report an issue at a given node. - typeChecker(): Access type checking utilities. - pythonFile(): Access file-level information. -- Tree.Kind (org.sonar.plugins.python.api.tree.Tree.Kind): - Used to register node consumers and to check node types (e.g., Kind.CALL_EXPR, Kind.FUNCDEF, Kind.CLASSDEF, etc.). -Patterns: - Use context.registerSyntaxNodeConsumer(Kind.X, this::method) in initialize to register callbacks for AST node kinds. - Use type checks and TypeCheckMap for rules that depend on type information. - Prefer using TypeV2 instead of the V1 symbols - When initializing TypeCheckBuilder objects, make a separate method. - In general, the callbacks should be in their own functions and not a lambda - Make sure to use the correct classes, for exemple most of the Tree objects have names that do not end in Tree. Before using, make sure the types exist. - When building type checkers, always recreate the builder from the context. Do not reuse one. - When casting to a tree, use a variable name that makes sense like expr, callExpression, ... \ No newline at end of file +`.claude/skills/rule-implementation/SKILL.md` + +Read that skill and follow it whenever implementing, placing, or wiring a new or existing Python check (open-source or enterprise). diff --git a/.github/renovate.json b/.github/renovate.json new file mode 100644 index 0000000000..7bf2d231e3 --- /dev/null +++ b/.github/renovate.json @@ -0,0 +1,32 @@ +{ + "$schema": "https://docs.renovatebot.com/renovate-schema.json", + "extends": [ + "github>SonarSource/renovate-config:quality-corelang-squad" + ], + "ignorePaths": [ + "python-frontend/typeshed_serializer/**" + ], + "packageRules": [ + { + "description": "Keep Python on 3.9 for typeshed serialization", + "matchManagers": [ + "mise" + ], + "matchDepNames": [ + "python" + ], + "allowedVersions": "<3.10" + }, + { + "description": "Keep protobuf Java and protoc compatible with the Python runtime used for typeshed serialization", + "matchDatasources": [ + "maven" + ], + "matchPackageNames": [ + "com.google.protobuf:protobuf-java", + "com.google.protobuf:protoc" + ], + "allowedVersions": "<=4.29.3" + } + ] +} diff --git a/.github/scripts/verify-fix-versions.sh b/.github/scripts/verify-fix-versions.sh index 1d93e10095..fb364717f2 100644 --- a/.github/scripts/verify-fix-versions.sh +++ b/.github/scripts/verify-fix-versions.sh @@ -46,8 +46,20 @@ get_commits_since_tag() { extract_jira_tickets() { local commits="$1" + local tickets + local extract_exit_code=0 # Extract SONARPY-XXXX patterns, remove duplicates, and sort - echo "$commits" | grep -oE "${JIRA_PROJECT_KEY}-[0-9]+" | sort -u + set +e + tickets=$(printf '%s\n' "$commits" | grep -oE "${JIRA_PROJECT_KEY}-[0-9]+" | sort -u) + extract_exit_code=$? + set -e + + if [[ "$extract_exit_code" -gt 1 ]]; then + echo "Error: Failed to extract Jira tickets from commits" >&2 + exit 1 + fi + + printf '%s' "$tickets" } build_jql_query() { @@ -293,4 +305,3 @@ main() { main "$@" - diff --git a/.github/workflows/SlackNotify.yml b/.github/workflows/SlackNotify.yml index 9c168d68ca..bc7c655c42 100644 --- a/.github/workflows/SlackNotify.yml +++ b/.github/workflows/SlackNotify.yml @@ -19,4 +19,4 @@ jobs: GITHUB_TOKEN: ${{ github.token }} uses: SonarSource/gh-action_slack-notify@1.0.1 with: - slackChannel: squad-python-notifs + slackChannel: squad-corelang-notifs diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 4c039882eb..8e043f711b 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -48,9 +48,9 @@ jobs: git sparse-checkout set stubs/sklearn git checkout - - uses: jdx/mise-action@146a28175021df8ca24f8ee1828cc2a60f980bd5 # v3.5.1 + - uses: jdx/mise-action@e79ddf65a11cec7b0e882bedced08d6e976efb2d # v3.6.2 with: - version: 2025.12.12 + version: 2026.5.15 cache: false env: MISE_ENV: test-and-analyze diff --git a/.gitignore b/.gitignore index 43b7a5243b..a4fc91cfd6 100644 --- a/.gitignore +++ b/.gitignore @@ -41,6 +41,7 @@ venv .coverage cov.xml __pycache__ +**/.python-ai-tool-cache/ python-frontend/typeshed_serializer/serializer/proto_out python-frontend/typeshed_serializer/output/* diff --git a/.mcp.json b/.mcp.json new file mode 100644 index 0000000000..6be127ca60 --- /dev/null +++ b/.mcp.json @@ -0,0 +1,13 @@ +{ + "mcpServers": { + "sonarqube": { + "command": "sonar", + "args": [ + "run", + "mcp", + "--project", + "SonarSource_sonar-python-enterprise" + ] + } + } +} diff --git a/NOTICE.txt b/NOTICE.txt index cb53f06841..2713507737 100644 --- a/NOTICE.txt +++ b/NOTICE.txt @@ -1,6 +1,11 @@ -Python -Copyright (C) 2011-2025 SonarSource Sàrl +Copyright (C) SonarSource Sàrl mailto:info AT sonarsource DOT com This product includes software developed at -SonarSource (http://www.sonarsource.com/). +SonarSource (https://sonarsource.com/). + +See LICENSE.txt file for details of the +applicable license. + +For further legal information, see +https://sonarsource.com/legal/ diff --git a/docs/pom.xml b/docs/pom.xml index 4c268268c0..2a3d972ff1 100644 --- a/docs/pom.xml +++ b/docs/pom.xml @@ -5,7 +5,7 @@ org.sonarsource.python python - 5.19-SNAPSHOT + 5.30-SNAPSHOT docs diff --git a/docs/python-custom-rules-example/pom.xml b/docs/python-custom-rules-example/pom.xml index b0813615ce..ecf69487f2 100644 --- a/docs/python-custom-rules-example/pom.xml +++ b/docs/python-custom-rules-example/pom.xml @@ -6,7 +6,7 @@ org.sonarsource.python docs - 5.19-SNAPSHOT + 5.30.0.36259 python-custom-rules-example @@ -29,8 +29,8 @@ sonar-analyzer-commons - org.sonarsource.sonarqube - sonar-plugin-api-impl + org.sonarsource.scanner.engine + sensor-test-fixtures test @@ -76,8 +76,8 @@ maven-compiler-plugin 3.15.0 - 17 - 17 + 21 + 21 diff --git a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/CustomPythonRuleRepository.java b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/CustomPythonRuleRepository.java index 3b2c7282e3..cb8de1fd24 100644 --- a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/CustomPythonRuleRepository.java +++ b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/CustomPythonRuleRepository.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ package org.sonar.samples.python; diff --git a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/CustomPythonRulesPlugin.java b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/CustomPythonRulesPlugin.java index 98497c808e..3b5ad3e8e6 100644 --- a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/CustomPythonRulesPlugin.java +++ b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/CustomPythonRulesPlugin.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ package org.sonar.samples.python; diff --git a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/RulesList.java b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/RulesList.java index 731857b294..8b807159f9 100644 --- a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/RulesList.java +++ b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/RulesList.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ package org.sonar.samples.python; diff --git a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/CustomPythonSubscriptionCheck.java b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/CustomPythonSubscriptionCheck.java index 6b95f7a9c9..79ef935640 100644 --- a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/CustomPythonSubscriptionCheck.java +++ b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/CustomPythonSubscriptionCheck.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ package org.sonar.samples.python.checks; diff --git a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/CustomPythonVisitorCheck.java b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/CustomPythonVisitorCheck.java index dd432e417f..576e88206b 100644 --- a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/CustomPythonVisitorCheck.java +++ b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/CustomPythonVisitorCheck.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ package org.sonar.samples.python.checks; diff --git a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/package-info.java b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/package-info.java index ec4f65e778..9eb6b26be4 100644 --- a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/package-info.java +++ b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/checks/package-info.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ @ParametersAreNonnullByDefault diff --git a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/package-info.java b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/package-info.java index 0541ae28d7..176bab3330 100644 --- a/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/package-info.java +++ b/docs/python-custom-rules-example/src/main/java/org/sonar/samples/python/package-info.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ @ParametersAreNonnullByDefault diff --git a/docs/python-custom-rules-example/src/main/resources/license-header.txt b/docs/python-custom-rules-example/src/main/resources/license-header.txt index 27a2c5c0c2..e4522e0453 100644 --- a/docs/python-custom-rules-example/src/main/resources/license-header.txt +++ b/docs/python-custom-rules-example/src/main/resources/license-header.txt @@ -1,2 +1,2 @@ -Copyright (C) ${license.years} ${license.owner} - ${license.mailto} +Copyright (C) ${license.owner} - ${license.mailto} This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. \ No newline at end of file diff --git a/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/CustomPythonRuleRepositoryTest.java b/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/CustomPythonRuleRepositoryTest.java index 71388e1bb8..734c22eeb7 100644 --- a/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/CustomPythonRuleRepositoryTest.java +++ b/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/CustomPythonRuleRepositoryTest.java @@ -1,14 +1,14 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ package org.sonar.samples.python; +import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime; import org.junit.jupiter.api.Test; import org.sonar.api.SonarEdition; import org.sonar.api.SonarQubeSide; import org.sonar.api.SonarRuntime; -import org.sonar.api.internal.SonarRuntimeImpl; import org.sonar.api.server.rule.RulesDefinition; import org.sonar.api.utils.Version; @@ -18,7 +18,7 @@ class CustomPythonRuleRepositoryTest { @Test void test_rule_repository() { - SonarRuntime sonarRuntime = SonarRuntimeImpl.forSonarQube(Version.create(9, 9), SonarQubeSide.SCANNER, SonarEdition.DEVELOPER); + SonarRuntime sonarRuntime = TestSonarRuntime.forSonarQube(Version.create(9, 9), SonarQubeSide.SCANNER, SonarEdition.DEVELOPER); CustomPythonRuleRepository customPythonRuleRepository = new CustomPythonRuleRepository(sonarRuntime); RulesDefinition.Context context = new RulesDefinition.Context(); customPythonRuleRepository.define(context); diff --git a/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/CustomPythonRulesPluginTest.java b/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/CustomPythonRulesPluginTest.java index 0f67bb6abd..9f0c7e6c3f 100644 --- a/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/CustomPythonRulesPluginTest.java +++ b/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/CustomPythonRulesPluginTest.java @@ -1,16 +1,15 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ package org.sonar.samples.python; +import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime; import org.junit.jupiter.api.Test; import org.sonar.api.Plugin; import org.sonar.api.SonarEdition; import org.sonar.api.SonarQubeSide; import org.sonar.api.SonarRuntime; -import org.sonar.api.internal.PluginContextImpl; -import org.sonar.api.internal.SonarRuntimeImpl; import org.sonar.api.utils.Version; import static org.assertj.core.api.Assertions.assertThat; @@ -18,8 +17,8 @@ class CustomPythonRulesPluginTest { @Test void test() { - SonarRuntime sonarRuntime = SonarRuntimeImpl.forSonarQube(Version.create(9, 9), SonarQubeSide.SCANNER, SonarEdition.DEVELOPER); - Plugin.Context context = new PluginContextImpl.Builder().setSonarRuntime(sonarRuntime).build(); + SonarRuntime sonarRuntime = TestSonarRuntime.forSonarQube(Version.create(9, 9), SonarQubeSide.SCANNER, SonarEdition.DEVELOPER); + Plugin.Context context = new Plugin.Context(sonarRuntime); new CustomPythonRulesPlugin().define(context); assertThat(context.getExtensions()).hasSize(1); } diff --git a/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/checks/CustomPythonSubscriptionCheckTest.java b/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/checks/CustomPythonSubscriptionCheckTest.java index 8bf2576ca4..8a647c954f 100644 --- a/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/checks/CustomPythonSubscriptionCheckTest.java +++ b/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/checks/CustomPythonSubscriptionCheckTest.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ package org.sonar.samples.python.checks; diff --git a/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/checks/CustomPythonVisitorCheckTest.java b/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/checks/CustomPythonVisitorCheckTest.java index 4d7129f4ec..4baf79b817 100644 --- a/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/checks/CustomPythonVisitorCheckTest.java +++ b/docs/python-custom-rules-example/src/test/java/org/sonar/samples/python/checks/CustomPythonVisitorCheckTest.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2025 SonarSource Sàrl - mailto:info AT sonarsource DOT com + * Copyright (C) SonarSource Sàrl - mailto:info AT sonarsource DOT com * This code is released under [MIT No Attribution](https://opensource.org/licenses/MIT-0) license. */ package org.sonar.samples.python.checks; diff --git a/its/commons/pom.xml b/its/commons/pom.xml index 6245d8ea3d..9972187433 100644 --- a/its/commons/pom.xml +++ b/its/commons/pom.xml @@ -6,7 +6,7 @@ org.sonarsource.python python-its - 5.19-SNAPSHOT + 5.30.0.36259 Python :: ITs :: Commons diff --git a/its/commons/src/test/java/com/sonar/python/it/ConcurrentOrchestratorExtension.java b/its/commons/src/test/java/com/sonar/python/it/ConcurrentOrchestratorExtension.java index 1376942bcd..2153b333aa 100644 --- a/its/commons/src/test/java/com/sonar/python/it/ConcurrentOrchestratorExtension.java +++ b/its/commons/src/test/java/com/sonar/python/it/ConcurrentOrchestratorExtension.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/commons/src/test/java/com/sonar/python/it/IssueListAssert.java b/its/commons/src/test/java/com/sonar/python/it/IssueListAssert.java index 9711892cd3..4c60760146 100644 --- a/its/commons/src/test/java/com/sonar/python/it/IssueListAssert.java +++ b/its/commons/src/test/java/com/sonar/python/it/IssueListAssert.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/commons/src/test/java/com/sonar/python/it/IssueListAssertTest.java b/its/commons/src/test/java/com/sonar/python/it/IssueListAssertTest.java index afe59aca66..2d53d04db7 100644 --- a/its/commons/src/test/java/com/sonar/python/it/IssueListAssertTest.java +++ b/its/commons/src/test/java/com/sonar/python/it/IssueListAssertTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/commons/src/test/java/com/sonar/python/it/PluginLocator.java b/its/commons/src/test/java/com/sonar/python/it/PluginLocator.java index b870b4f0af..cf391e79a1 100644 --- a/its/commons/src/test/java/com/sonar/python/it/PluginLocator.java +++ b/its/commons/src/test/java/com/sonar/python/it/PluginLocator.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -33,7 +33,7 @@ public enum Plugins { new LocalPlugin("../python-custom-rules-plugin/target", "python-custom-rules-plugin-*.jar"), new LocalPlugin("../../../its/plugin/python-custom-rules-plugin/target", "python-custom-rules-plugin-*.jar")), PYTHON_CUSTOM_RULES_EXAMPLE( - new LocalPlugin("../../docs/python-custom-rules-example/target", "python-custom-rules-example-*.jar"), + new LocalPlugin("../../../docs/python-custom-rules-example/target", "python-custom-rules-example-*.jar"), new LocalPlugin("../../../docs/python-custom-rules-example/target", "python-custom-rules-example-*.jar")); private final LocalPlugin ossPlugin; diff --git a/its/commons/src/test/java/com/sonar/python/it/TestsUtils.java b/its/commons/src/test/java/com/sonar/python/it/TestsUtils.java index 485fe8a6a9..8fb3222de7 100644 --- a/its/commons/src/test/java/com/sonar/python/it/TestsUtils.java +++ b/its/commons/src/test/java/com/sonar/python/it/TestsUtils.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -57,10 +57,8 @@ private static ConcurrentOrchestratorExtension.ConcurrentOrchestratorExtensionBu var builder = ConcurrentOrchestratorExtension.builderEnv() .useDefaultAdminCredentialsForBuilds(true) .setSonarVersion(System.getProperty(SQ_VERSION_PROPERTY, DEFAULT_SQ_VERSION)) - // Disable telemetry waiting for ORCH-497 + // Disable telemetry to avoid external network calls during tests .setServerProperty("sonar.telemetry.enable", "false") - - // Custom rules plugin .addPlugin(Plugins.PYTHON_CUSTOM_RULES.get(isEnterprise)) .addPlugin(Plugins.PYTHON_CUSTOM_RULES_EXAMPLE.get(isEnterprise)) .restoreProfileAtStartup(FileLocation.of("profiles/profile-python-custom-rules-example.xml")) diff --git a/its/plugin/it-python-plugin-test/pom.xml b/its/plugin/it-python-plugin-test/pom.xml index 9fa5c35be7..87da778e3e 100644 --- a/its/plugin/it-python-plugin-test/pom.xml +++ b/its/plugin/it-python-plugin-test/pom.xml @@ -7,7 +7,7 @@ it-python-plugin org.sonarsource.python - 5.19-SNAPSHOT + 5.30.0.36259 it-python-plugin-test @@ -35,7 +35,21 @@ org.sonarsource.sonarlint.core - sonarlint-core + sonarlint-core-test-utils + ${sonarlint-core.version} + test + + + org.sonarsource.sonarlint.core + sonarlint-rpc-protocol + ${sonarlint-core.version} + test + + + + com.fasterxml.jackson.core + jackson-annotations + 2.22 test @@ -60,6 +74,12 @@ ${sonar.version} test + + org.awaitility + awaitility + 4.3.0 + test + org.sonarsource.orchestrator sonar-orchestrator-junit5 diff --git a/its/plugin/it-python-plugin-test/profiles/nosonar.xml b/its/plugin/it-python-plugin-test/profiles/nosonar.xml index aa89d670ff..4da1b3fb8c 100644 --- a/its/plugin/it-python-plugin-test/profiles/nosonar.xml +++ b/its/plugin/it-python-plugin-test/profiles/nosonar.xml @@ -22,5 +22,10 @@ S1309 INFO + + python + S4423 + INFO + diff --git a/its/plugin/it-python-plugin-test/projects/coverage_project_projectbasedir/app/coverage.xml b/its/plugin/it-python-plugin-test/projects/coverage_project_projectbasedir/app/coverage.xml new file mode 100644 index 0000000000..0b21d1a5f8 --- /dev/null +++ b/its/plugin/it-python-plugin-test/projects/coverage_project_projectbasedir/app/coverage.xml @@ -0,0 +1,20 @@ + + + + + src + + + + + + + + + + + + + + diff --git a/its/plugin/it-python-plugin-test/projects/coverage_project_projectbasedir/app/src/prod.py b/its/plugin/it-python-plugin-test/projects/coverage_project_projectbasedir/app/src/prod.py new file mode 100644 index 0000000000..7d4290a117 --- /dev/null +++ b/its/plugin/it-python-plugin-test/projects/coverage_project_projectbasedir/app/src/prod.py @@ -0,0 +1 @@ +x = 1 diff --git a/its/plugin/it-python-plugin-test/projects/nosonar/nosec-project/main.py b/its/plugin/it-python-plugin-test/projects/nosonar/nosec-project/main.py new file mode 100644 index 0000000000..8789095fa9 --- /dev/null +++ b/its/plugin/it-python-plugin-test/projects/nosonar/nosec-project/main.py @@ -0,0 +1,26 @@ +import ssl + +# Bare nosec suppresses every rule on the line (Bandit semantics). +ssl.SSLContext(ssl.PROTOCOL_TLSv1) +ssl.SSLContext(ssl.PROTOCOL_TLSv1) # nosec + +# Scoped nosec with a Bandit ID narrows suppression to that ID; B502 has no Sonar mapping, so S4423 still fires. +ssl.SSLContext(ssl.PROTOCOL_TLSv1) # nosec B502 legacy peer + +# Selective suppression by Sonar rule key. +ssl.SSLContext(ssl.PROTOCOL_TLSv1) # nosec S4423 + +# Selective suppression narrows to the listed keys; OneStatementPerLine still fires. +ssl.SSLContext(ssl.PROTOCOL_TLSv1); ssl.SSLContext(ssl.PROTOCOL_TLSv1_1) # nosec S4423 + +# Baseline: two S4423 + OneStatementPerLine all fire. +ssl.SSLContext(ssl.PROTOCOL_TLSv1); ssl.SSLContext(ssl.PROTOCOL_TLSv1_1) + +# Bare nosec suppresses security rules but lets non-security rules (e.g. OneStatementPerLine) through. +ssl.SSLContext(ssl.PROTOCOL_TLSv1); ssl.SSLContext(ssl.PROTOCOL_TLSv1_1) # nosec + +# Trailing directive on the last statement. +ssl.SSLContext(ssl.PROTOCOL_TLSv1) # nosec + +# Selective suppression lets S4423 through +ssl.SSLContext(ssl.PROTOCOL_TLSv1) # nosec S1234 diff --git a/its/plugin/it-python-plugin-test/projects/ruff_project/ruff-report-absolute-path-from-other-machine.json b/its/plugin/it-python-plugin-test/projects/ruff_project/ruff-report-absolute-path-from-other-machine.json new file mode 100644 index 0000000000..7a87797c24 --- /dev/null +++ b/its/plugin/it-python-plugin-test/projects/ruff_project/ruff-report-absolute-path-from-other-machine.json @@ -0,0 +1,34 @@ +[ + { + "code": "F821", + "end_location": { + "column": 48, + "row": 7 + }, + "filename": "/home/other-user/some/other/checkout/ruff_project/src/file1.py", + "fix": null, + "location": { + "column": 42, + "row": 7 + }, + "message": "Undefined name `random`", + "noqa_row": 7, + "url": "https://beta.ruff.rs/docs/rules/undefined-name" + }, + { + "code": "E501", + "end_location": { + "column": 109, + "row": 7 + }, + "filename": "/home/other-user/some/other/checkout/ruff_project/src/file1.py", + "fix": null, + "location": { + "column": 89, + "row": 7 + }, + "message": "Line too long (108 > 88 characters)", + "noqa_row": 7, + "url": "https://beta.ruff.rs/docs/rules/line-too-long" + } +] diff --git a/its/plugin/it-python-plugin-test/projects/test_code/main_src/.gitkeep b/its/plugin/it-python-plugin-test/projects/test_code/main_src/.gitkeep new file mode 100644 index 0000000000..e69de29bb2 diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/BanditReportTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/BanditReportTest.java index 79f67e8f6d..6cf1f85989 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/BanditReportTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/BanditReportTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CPDTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CPDTest.java index 4db54af4ba..eff82729e4 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CPDTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CPDTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CoverageTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CoverageTest.java index fcd6f6482d..97f4ee9592 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CoverageTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CoverageTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -25,6 +25,7 @@ import java.io.File; import java.util.HashMap; import java.util.Map; +import java.util.regex.Pattern; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -33,10 +34,12 @@ public class CoverageTest { private static final String COVERAGE_PROJECT = "projects/coverage_project"; + private static final String COVERAGE_PROJECT_PROJECT_BASEDIR = "projects/coverage_project_projectbasedir"; @RegisterExtension public static final ConcurrentOrchestratorExtension ORCHESTRATOR = TestsUtils.dynamicOrchestrator; private static final String PROJECT_KEY = "coverage_project"; + private static final String PROJECT_BASEDIR_KEY = "coverage_project_projectbasedir"; private static final String LINES_TO_COVER = "lines_to_cover"; private static final String COVERAGE = "coverage"; private static final String LINE_COVERAGE = "line_coverage"; @@ -44,6 +47,8 @@ public class CoverageTest { private static final String EMPTY_XML = "empty.xml"; private static final String DEPRECATED_COVERAGE_REPORT_PATH = "sonar.python.coverage.reportPath"; private static final String COVERAGE_REPORT_PATHS = "sonar.python.coverage.reportPaths"; + private static final Pattern LINE_SEPARATOR = Pattern.compile("[\\r\\n]+"); + private static final Pattern EMPTY_REPORT_LOG = Pattern.compile("The report '[^']*' seems to be empty, ignoring"); @Test void basic_coverage_reports_with_unix_paths() { @@ -113,14 +118,35 @@ void empty_coverage_report() { .setProperty(COVERAGE_REPORT_PATHS, EMPTY_XML); BuildResult buildResult = ORCHESTRATOR.executeBuild(build); - int nbLog = 0; - for (String s : buildResult.getLogs().split("[\\r\\n]+")) { - if (s.matches(".*The report '[^']*' seems to be empty, ignoring.*")) { - nbLog++; - } - } + long nbLog = LINE_SEPARATOR.splitAsStream(buildResult.getLogs()) + .filter(line -> EMPTY_REPORT_LOG.matcher(line).find()) + .count(); assertThat(nbLog).isEqualTo(1); assertThat(TestsUtils.getMeasureAsDouble(PROJECT_KEY, COVERAGE)).isZero(); } + @Test + void relative_source_paths_are_resolved_from_project_base_dir() { + File projectDir = new File(COVERAGE_PROJECT_PROJECT_BASEDIR); + File projectBaseDir = new File(projectDir, "app"); + SonarScanner build = ORCHESTRATOR.createSonarScanner() + .setProjectDir(projectDir) + .setProperty("sonar.projectKey", PROJECT_BASEDIR_KEY) + .setProperty("sonar.projectName", PROJECT_BASEDIR_KEY) + .setProperty("sonar.projectVersion", "1") + .setProperty("sonar.sourceEncoding", "UTF8") + .setProperty("sonar.projectBaseDir", projectBaseDir.getAbsolutePath()) + .setProperty("sonar.sources", "src") + .setProperty(COVERAGE_REPORT_PATHS, "coverage.xml"); + + ORCHESTRATOR.executeBuild(build); + + Map expected = new HashMap<>(); + expected.put(LINES_TO_COVER, 1); + expected.put(COVERAGE, 100); + expected.put(LINE_COVERAGE, 100); + expected.put(BRANCH_COVERAGE, null); + TestsUtils.assertProjectMeasures(PROJECT_BASEDIR_KEY, expected); + } + } diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CustomRulesExampleTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CustomRulesExampleTest.java index 7cfab5ff47..742d90354e 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CustomRulesExampleTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CustomRulesExampleTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CustomRulesTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CustomRulesTest.java index 640190912d..ee062eada3 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CustomRulesTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/CustomRulesTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/Flake8ReportTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/Flake8ReportTest.java index 5ee3c1c5ef..27d97e7fa4 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/Flake8ReportTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/Flake8ReportTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/MetricsTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/MetricsTest.java index 6efd0d53db..8a84908a5e 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/MetricsTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/MetricsTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -75,7 +75,11 @@ static void startServer() { @Test void project_level() { // Size - assertThat(getProjectMeasureAsInt(NCLOC)).isEqualTo(6); + assertThat(getProjectMeasureAsInt(NCLOC)).satisfiesAnyOf( + nclocValue -> assertThat(nclocValue).isEqualTo(6), + // FIXME SONAR-27110 Can be removed when ITs will be run with SQS 2026.2+ + nclocValue -> assertThat(nclocValue).isEqualTo(20) + ); assertThat(getProjectMeasureAsInt(LINES)).isEqualTo(13); assertThat(getProjectMeasureAsInt(FILES)).isEqualTo(2); assertThat(getProjectMeasureAsInt(STATEMENTS)).isEqualTo(6); @@ -83,7 +87,11 @@ void project_level() { assertThat(getProjectMeasureAsInt(CLASSES)).isZero(); // Documentation assertThat(getProjectMeasureAsInt(COMMENT_LINES)).isOne(); - assertThat(getProjectMeasureAsDouble(COMMENT_LINES_DENSITY)).isEqualTo(14.3, OFFSET); + assertThat(getProjectMeasureAsDouble(COMMENT_LINES_DENSITY)) + .satisfiesAnyOf( + density -> assertThat(density).isEqualTo(14.3, OFFSET), + // FIXME SONAR-27110 Can be removed when ITs will be run with SQS 2026.2+ + density -> assertThat(density).isEqualTo(4.8, OFFSET)); // Complexity assertThat(getProjectMeasureAsDouble(COMPLEXITY)).isEqualTo(3.0, OFFSET); assertThat(getProjectMeasureAsDouble(COGNITIVE_COMPLEXITY)).isEqualTo(3.0, OFFSET); diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/MypyReportTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/MypyReportTest.java index 1a585a69a0..c089adb3c9 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/MypyReportTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/MypyReportTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/NoSonarTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/NoSonarTest.java index be2da2eee9..365b3f08ef 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/NoSonarTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/NoSonarTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -31,6 +31,7 @@ public class NoSonarTest { private static final String NO_SONAR_PROJECT_KEY = "nosonar"; private static final String EXTERNAL_ISSUE_PROJECT_KEY = "external-issues"; private static final String NOQA_PROJECT_KEY = "noqa"; + private static final String NO_SEC_PROJECT_KEY = "nosec"; private static final String PROFILE_NAME = "nosonar"; @@ -132,6 +133,48 @@ void test_noqa() { .containsIssue(22, "python:S1309").doesNotContainIssue(22, "python:PrintStatementUsage"); } + @Test + void test_nosec() { + analyzeProject(createScanner(NO_SEC_PROJECT_KEY, "projects/nosonar/nosec-project")); + + IssueListAssert.assertThat(issues(NO_SEC_PROJECT_KEY)) + .hasSize(15) + // bare nosec suppresses security rules on the line; S1309 still fires (whitelisted) + .containsIssue(4, "python:S4423") + .doesNotContainIssue(5, "python:S4423") + .containsIssue(5, "python:S1309") + + // scoped bandit ID has no Sonar mapping, so S4423 still fires + .containsIssue(8, "python:S4423") + .containsIssue(8, "python:S1309") + + // selective suppression by Sonar rule key + .doesNotContainIssue(11, "python:S4423") + .containsIssue(11, "python:S1309") + + // selective suppression narrows to listed keys; OneStatementPerLine still fires + .doesNotContainIssue(14, "python:S4423") + .containsIssue(14, "python:OneStatementPerLine") + .containsIssue(14, "python:S1309") + + // baseline: 2 x S4423 + OneStatementPerLine all fire + .containsIssue(17, "python:S4423") + .containsIssue(17, "python:OneStatementPerLine") + + // bare nosec suppresses security rules (S4423) but not non-security rules (OneStatementPerLine) + .doesNotContainIssue(20, "python:S4423") + .containsIssue(20, "python:OneStatementPerLine") + .containsIssue(20, "python:S1309") + + // nosec at end of file + .doesNotContainIssue(23, "python:S4423") + .containsIssue(23, "python:S1309") + + // scoped nosec with unrelated key does not suppress S4423 + .containsIssue(26, "python:S4423") + .containsIssue(26, "python:S1309"); + } + private void analyzeProject(SonarScanner scanner) { String projectKey = scanner.getProperty("sonar.projectKey"); ORCHESTRATOR.getServer().provisionProject(projectKey, projectKey); diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/NotebookPluginTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/NotebookPluginTest.java index ab62281b76..a2641eae78 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/NotebookPluginTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/NotebookPluginTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/PylintReportTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/PylintReportTest.java index 38aa064175..49ccd8552b 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/PylintReportTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/PylintReportTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/RuffReportTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/RuffReportTest.java index 54056c29f6..449c145a49 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/RuffReportTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/RuffReportTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -66,4 +66,29 @@ void import_report() { } + @Test + void import_report_with_absolute_path_from_different_base_dir() { + final String projectKey = "ruff_project_absolute_path"; + ORCHESTRATOR.getServer().provisionProject(projectKey, projectKey); + ORCHESTRATOR.getServer().associateProjectToQualityProfile(projectKey, "py", "no_rule"); + ORCHESTRATOR.executeBuild( + ORCHESTRATOR.createSonarScanner() + .setProjectDir(new File("projects/ruff_project")) + .setProjectKey(projectKey) + .setProjectName(projectKey) + .setProperty("sonar.python.ruff.reportPaths", "ruff-report-absolute-path-from-other-machine.json")); + + List issues = issues(projectKey).stream().sorted(Comparator.comparing(Issues.Issue::getRule)) + .toList(); + assertThat(issues).hasSize(2); + + Issues.Issue firstIssue = issues.get(0); + assertThat(firstIssue.getComponent()).isEqualTo(projectKey + ":src/file1.py"); + assertThat(firstIssue.getRule()).isEqualTo("external_ruff:E501"); + + Issues.Issue secondIssue = issues.get(1); + assertThat(secondIssue.getComponent()).isEqualTo(projectKey + ":src/file1.py"); + assertThat(secondIssue.getRule()).isEqualTo("external_ruff:F821"); + } + } diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintBackendTestUtils.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintBackendTestUtils.java new file mode 100644 index 0000000000..ed8154f19f --- /dev/null +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintBackendTestUtils.java @@ -0,0 +1,150 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package com.sonar.python.it.plugin; + +import static org.awaitility.Awaitility.await; + +import com.sonar.python.it.PluginLocator; +import java.io.IOException; +import java.io.UncheckedIOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.time.Duration; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import java.util.regex.Pattern; +import org.sonarsource.sonarlint.core.rpc.protocol.backend.file.DidOpenFileParams; +import org.sonarsource.sonarlint.core.rpc.protocol.backend.rules.StandaloneRuleConfigDto; +import org.sonarsource.sonarlint.core.rpc.protocol.backend.rules.UpdateStandaloneRulesConfigurationParams; +import org.sonarsource.sonarlint.core.rpc.protocol.client.issue.RaisedIssueDto; +import org.sonarsource.sonarlint.core.rpc.protocol.common.ClientFileDto; +import org.sonarsource.sonarlint.core.rpc.protocol.common.Language; +import org.sonarsource.sonarlint.core.test.utils.SonarLintBackendFixture; +import org.sonarsource.sonarlint.core.test.utils.SonarLintTestRpcServer; +import org.sonarsource.sonarlint.core.test.utils.junit5.SonarLintTestHarness; +import org.sonarsource.sonarlint.core.test.utils.plugins.Plugin; + +final class SonarLintBackendTestUtils { + + static final String CONFIG_SCOPE_ID = "python-sonarlint-test"; + private static final Duration TIMEOUT = Duration.ofSeconds(15); + + private SonarLintBackendTestUtils() { + // utility class + } + + static ClientFileDto writeFile(Path baseDir, String relativePath, String content, Language language) { + var filePath = baseDir.resolve(relativePath); + try { + Files.createDirectories(filePath.getParent()); + Files.writeString(filePath, content, StandardCharsets.UTF_8); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + return clientFile(baseDir, filePath, language); + } + + static ClientFileDto copyFile(Path baseDir, Path sourceFile, String relativePath, Language language) { + var targetPath = baseDir.resolve(relativePath); + try { + Files.createDirectories(targetPath.getParent()); + Files.copy(sourceFile, targetPath); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + return clientFile(baseDir, targetPath, language); + } + + static SonarLintBackendFixture.FakeSonarLintRpcClient createClient(SonarLintTestHarness harness, Path baseDir, ClientFileDto... inputFiles) { + return harness.newFakeClient() + .withInitialFs(CONFIG_SCOPE_ID, baseDir, List.of(inputFiles)) + .build(); + } + + static SonarLintTestRpcServer startBackend(SonarLintTestHarness harness, SonarLintBackendFixture.FakeSonarLintRpcClient client, + Set languages, Set activeRuleKeys) { + var backend = harness.newBackend() + .withStandaloneEmbeddedPluginAndEnabledLanguage(new Plugin(languages, pythonPluginLocation(), "", "")) + .withUnboundConfigScope(CONFIG_SCOPE_ID) + .start(client); + + var rulesByKey = backend.getRulesService().listAllStandaloneRulesDefinitions().join().getRulesByKey(); + if (!rulesByKey.keySet().containsAll(activeRuleKeys)) { + throw new IllegalStateException("Missing standalone SonarLint rules: " + activeRuleKeys.stream() + .filter(ruleKey -> !rulesByKey.containsKey(ruleKey)) + .toList()); + } + + var ruleConfigByKey = rulesByKey.values().stream() + .filter(rule -> languages.contains(rule.getLanguage())) + .collect(Collectors.toMap( + rule -> rule.getKey(), + rule -> new StandaloneRuleConfigDto(activeRuleKeys.contains(rule.getKey()), Map.of()))); + backend.getRulesService().updateStandaloneRulesConfiguration(new UpdateStandaloneRulesConfigurationParams(ruleConfigByKey)); + return backend; + } + + static void openFile(SonarLintTestRpcServer backend, ClientFileDto inputFile) { + backend.getFileService().didOpenFile(new DidOpenFileParams(CONFIG_SCOPE_ID, inputFile.getUri())); + } + + static void awaitIssues(SonarLintBackendFixture.FakeSonarLintRpcClient client, + Consumer>> assertion) { + await() + .atMost(TIMEOUT) + .untilAsserted(() -> assertion.accept(client.getRaisedIssuesForScopeId(CONFIG_SCOPE_ID))); + } + + private static ClientFileDto clientFile(Path baseDir, Path filePath, Language language) { + var absoluteBaseDir = baseDir.toAbsolutePath().normalize(); + var absoluteFilePath = filePath.toAbsolutePath().normalize(); + return new ClientFileDto( + absoluteFilePath.toUri(), + absoluteBaseDir.relativize(absoluteFilePath), + CONFIG_SCOPE_ID, + false, + StandardCharsets.UTF_8.name(), + absoluteFilePath, + null, + language, + true); + } + + private static Path pythonPluginLocation() { + return PluginLocator.isEnterpriseTest() + ? findPluginArtifact(Path.of("../../../private/sonar-python-enterprise-plugin/target"), + Pattern.compile("sonar-python-enterprise-plugin-[0-9.]*(?:-SNAPSHOT)?\\.jar")) + : findPluginArtifact(Path.of("../../../sonar-python-plugin/target"), + Pattern.compile("sonar-python-plugin-[0-9.]*(?:-SNAPSHOT)?\\.jar")); + } + + private static Path findPluginArtifact(Path targetDir, Pattern filenamePattern) { + var absoluteTargetDir = targetDir.toAbsolutePath().normalize(); + try (var entries = Files.list(absoluteTargetDir)) { + return entries + .filter(path -> filenamePattern.matcher(path.getFileName().toString()).matches()) + .findFirst() + .orElseThrow(() -> new IllegalStateException("Cannot find plugin artifact in " + absoluteTargetDir)); + } catch (IOException e) { + throw new UncheckedIOException("Failed to resolve plugin artifact from " + absoluteTargetDir, e); + } + } +} diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintIPythonTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintIPythonTest.java index b8f0d80617..f0d9b7c6ea 100755 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintIPythonTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintIPythonTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,187 +16,42 @@ */ package com.sonar.python.it.plugin; -import com.sonar.orchestrator.locator.Locators; -import com.sonar.python.it.PluginLocator; -import com.sonar.python.it.TestsUtils; -import java.io.IOException; -import java.io.InputStream; -import java.net.URI; -import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; -import java.nio.file.Files; import java.nio.file.Path; -import java.util.ArrayList; -import java.util.EnumMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; import java.util.Set; -import java.util.concurrent.ExecutionException; -import java.util.stream.Stream; -import javax.annotation.Nullable; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; -import org.sonar.api.batch.fs.InputFile; -import org.sonarsource.sonarlint.core.analysis.AnalysisEngine; -import org.sonarsource.sonarlint.core.analysis.api.ActiveRule; -import org.sonarsource.sonarlint.core.analysis.api.AnalysisConfiguration; -import org.sonarsource.sonarlint.core.analysis.api.AnalysisEngineConfiguration; -import org.sonarsource.sonarlint.core.analysis.api.ClientInputFile; -import org.sonarsource.sonarlint.core.analysis.api.ClientModuleFileSystem; -import org.sonarsource.sonarlint.core.analysis.api.ClientModuleInfo; -import org.sonarsource.sonarlint.core.analysis.api.Issue; -import org.sonarsource.sonarlint.core.analysis.api.WithTextRange; -import org.sonarsource.sonarlint.core.analysis.command.AnalyzeCommand; -import org.sonarsource.sonarlint.core.analysis.command.RegisterModuleCommand; -import org.sonarsource.sonarlint.core.commons.api.SonarLanguage; -import org.sonarsource.sonarlint.core.commons.log.LogOutput; -import org.sonarsource.sonarlint.core.commons.log.LogOutput.Level; -import org.sonarsource.sonarlint.core.commons.log.SonarLintLogger; -import org.sonarsource.sonarlint.core.commons.progress.ProgressMonitor; -import org.sonarsource.sonarlint.core.plugin.commons.PluginsLoader; +import org.sonarsource.sonarlint.core.rpc.protocol.common.Language; +import org.sonarsource.sonarlint.core.test.utils.junit5.SonarLintTest; +import org.sonarsource.sonarlint.core.test.utils.junit5.SonarLintTestHarness; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.tuple; public class SonarLintIPythonTest { - @TempDir - public static Path temp; - - private static AnalysisEngine sonarlintEngine; - private final ProgressMonitor progressMonitor = new ProgressMonitor(null); - - - @BeforeAll - static void prepare() { - var sonarLintConfig = AnalysisEngineConfiguration.builder() - .setWorkDir(temp) - .build(); - - var logOutput = new LogOutput() { - @Override - public void log(String formattedMessage, Level level, @Nullable String stacktrace) { - /* Don't pollute logs */ - } - }; - SonarLintLogger.setTarget(logOutput); - Locators locators = new Locators(TestsUtils.dynamicOrchestrator.getConfiguration()); - var pluginJarLocation = Set - .of(locators.locate(PluginLocator.Plugins.PYTHON.get(PluginLocator.isEnterpriseTest())).toPath()); - var enabledLanguages = Set.of(SonarLanguage.IPYTHON); - var pluginConfiguration = new PluginsLoader.Configuration(pluginJarLocation, enabledLanguages, false, Optional.empty()); - var pluginLoader = new PluginsLoader().load(pluginConfiguration, Set.of()); - - sonarlintEngine = new AnalysisEngine(sonarLintConfig, pluginLoader.getLoadedPlugins(), logOutput); - } - - @AfterAll - static void stop() { - SonarLintLogger.setTarget(null); - sonarlintEngine.stop(); - } - - @Test - void shouldRaiseIssues() throws InterruptedException, ExecutionException { - var inputFile = createInputFile(Path.of("projects/ipynb_project/file1.ipynb"), "file1.ipynb", false); - var issues = new ArrayList(); - - var configuration = AnalysisConfiguration.builder() - .setBaseDir(Path.of("projects/ipynb_project")) - .addInputFile(inputFile) - .addActiveRules(new ActiveRule("ipython:PrintStatementUsage", SonarLanguage.IPYTHON.name()), - new ActiveRule("ipython:S1172", SonarLanguage.IPYTHON.name()), - new ActiveRule("ipython:S930", SonarLanguage.IPYTHON.name()), - new ActiveRule("ipython:S1542", SonarLanguage.IPYTHON.name()), - new ActiveRule("ipython:BackticksUsage", SonarLanguage.IPYTHON.name())) - .build(); - - Map> logsByLevel = new EnumMap<>(Level.class); - var logOutput = createClientLogOutput(logsByLevel); - var clientFileSystem = createClientFileSystem(inputFile); - sonarlintEngine.post(new RegisterModuleCommand(new ClientModuleInfo("myModule", clientFileSystem)), progressMonitor).get(); - var command = new AnalyzeCommand("myModule", configuration, issues::add, logOutput); - sonarlintEngine.post(command, progressMonitor).get(); - assertThat(issues) - .extracting(Issue::getRuleKey, WithTextRange::getStartLine, i -> i.getInputFile().uri()) - .containsOnly( - tuple("ipython:PrintStatementUsage", 32, inputFile.uri()), - tuple("ipython:S1172", 40, inputFile.uri()), - tuple("ipython:S930", 41, inputFile.uri()), - tuple("ipython:S1172", 42, inputFile.uri()), - tuple("ipython:S1542", 57, inputFile.uri()), - tuple("ipython:BackticksUsage", 58, inputFile.uri())); - } - - private static LogOutput createClientLogOutput(Map> logsByLevel) { - return new LogOutput() { - @Override - public void log(String formattedMessage, Level level, @Nullable String stacktrace) { - logsByLevel.computeIfAbsent(level, k -> new ArrayList<>()).add(formattedMessage); - } - }; - } - - private static ClientModuleFileSystem createClientFileSystem(ClientInputFile... inputFiles) { - return new ClientModuleFileSystem() { - @Override - public Stream files(String s, InputFile.Type type) { - return Stream.of(inputFiles); - } - - @Override - public Stream files() { - return Stream.of(inputFiles); - } - }; - } - - private static ClientInputFile createInputFile(final Path path, String relativePath, final boolean isTest) { - return new ClientInputFile() { - - @Override - public String getPath() { - return path.toString(); - } - - @Override - public boolean isTest() { - return isTest; - } - - @Override - public Charset getCharset() { - return StandardCharsets.UTF_8; - } - - @Override - public G getClientObject() { - return null; - } - - @Override - public InputStream inputStream() throws IOException { - return Files.newInputStream(path); - } - - @Override - public String contents() throws IOException { - return new String(Files.readAllBytes(path), StandardCharsets.UTF_8); - } - - @Override - public String relativePath() { - return relativePath; - } - - @Override - public URI uri() { - return path.toUri(); - } - - }; + @SonarLintTest + void shouldRaiseIssues(SonarLintTestHarness harness, @TempDir Path baseDir) { + var fixture = Path.of("projects/ipynb_project/file1.ipynb"); + var inputFile = SonarLintBackendTestUtils.copyFile(baseDir, fixture, "file1.ipynb", Language.IPYTHON); + var client = SonarLintBackendTestUtils.createClient(harness, baseDir, inputFile); + var backend = SonarLintBackendTestUtils.startBackend( + harness, + client, + Set.of(Language.IPYTHON), + Set.of("ipython:PrintStatementUsage", "ipython:S1172", "ipython:S930", "ipython:S1542", "ipython:BackticksUsage")); + + SonarLintBackendTestUtils.openFile(backend, inputFile); + + SonarLintBackendTestUtils.awaitIssues(client, issuesByUri -> assertThat( + issuesByUri.entrySet().stream() + .flatMap(entry -> entry.getValue().stream() + .map(issue -> tuple(issue.getRuleKey(), issue.getTextRange().getStartLine(), entry.getKey()))) + .toList()) + .containsExactlyInAnyOrder( + tuple("ipython:PrintStatementUsage", 32, inputFile.getUri()), + tuple("ipython:S1172", 40, inputFile.getUri()), + tuple("ipython:S930", 41, inputFile.getUri()), + tuple("ipython:S1172", 42, inputFile.getUri()), + tuple("ipython:S1542", 57, inputFile.getUri()), + tuple("ipython:BackticksUsage", 58, inputFile.getUri()))); } } diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintTest.java index e5e9f4ed4a..67593ffc78 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/SonarLintTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,188 +16,43 @@ */ package com.sonar.python.it.plugin; -import com.sonar.orchestrator.locator.Locators; -import com.sonar.python.it.PluginLocator; -import com.sonar.python.it.TestsUtils; -import java.io.File; -import java.io.IOException; -import java.io.InputStream; -import java.net.URI; -import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; -import java.nio.file.Files; import java.nio.file.Path; -import java.util.ArrayList; -import java.util.EnumMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; import java.util.Set; -import java.util.concurrent.ExecutionException; -import java.util.stream.Stream; -import javax.annotation.Nullable; -import org.apache.commons.io.FileUtils; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; -import org.sonar.api.batch.fs.InputFile; -import org.sonarsource.sonarlint.core.analysis.AnalysisEngine; -import org.sonarsource.sonarlint.core.analysis.api.ActiveRule; -import org.sonarsource.sonarlint.core.analysis.api.AnalysisConfiguration; -import org.sonarsource.sonarlint.core.analysis.api.AnalysisEngineConfiguration; -import org.sonarsource.sonarlint.core.analysis.api.ClientInputFile; -import org.sonarsource.sonarlint.core.analysis.api.ClientModuleFileSystem; -import org.sonarsource.sonarlint.core.analysis.api.ClientModuleInfo; -import org.sonarsource.sonarlint.core.analysis.api.Issue; -import org.sonarsource.sonarlint.core.analysis.command.AnalyzeCommand; -import org.sonarsource.sonarlint.core.analysis.command.RegisterModuleCommand; -import org.sonarsource.sonarlint.core.commons.api.SonarLanguage; -import org.sonarsource.sonarlint.core.commons.log.LogOutput; -import org.sonarsource.sonarlint.core.commons.log.LogOutput.Level; -import org.sonarsource.sonarlint.core.commons.log.SonarLintLogger; -import org.sonarsource.sonarlint.core.commons.progress.ProgressMonitor; -import org.sonarsource.sonarlint.core.plugin.commons.PluginsLoader; +import org.sonarsource.sonarlint.core.rpc.protocol.common.Language; +import org.sonarsource.sonarlint.core.test.utils.junit5.SonarLintTestHarness; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.tuple; public class SonarLintTest { - @TempDir - public static Path temp; - - private static AnalysisEngine sonarlintEngine; - private final ProgressMonitor progressMonitor = new ProgressMonitor(null); - - private static File baseDir; - - @BeforeAll - static void prepare() { - var sonarLintConfig = AnalysisEngineConfiguration.builder() - .setWorkDir(temp) - .build(); - - var logOutput = new LogOutput() { - @Override - public void log(String formattedMessage, Level level, @Nullable String stacktrace) { - /* Don't pollute logs */ - } - }; - SonarLintLogger.setTarget(logOutput); - Locators locators = new Locators(TestsUtils.dynamicOrchestrator.getConfiguration()); - var pluginJarLocation = Set - .of(locators.locate(PluginLocator.Plugins.PYTHON.get(PluginLocator.isEnterpriseTest())).toPath()); - var enabledLanguages = Set.of(SonarLanguage.PYTHON); - var pluginConfiguration = new PluginsLoader.Configuration(pluginJarLocation, enabledLanguages, false, Optional.empty()); - var pluginLoader = new PluginsLoader().load(pluginConfiguration, Set.of()); - - sonarlintEngine = new AnalysisEngine(sonarLintConfig, pluginLoader.getLoadedPlugins(), logOutput); - baseDir = temp.toFile(); - } - - @AfterAll - static void stop() { - SonarLintLogger.setTarget(null); - sonarlintEngine.stop(); - } - - @Test - void should_raise_issues() throws IOException, InterruptedException, ExecutionException { - ClientInputFile inputFile = prepareInputFile("foo.py", + @org.sonarsource.sonarlint.core.test.utils.junit5.SonarLintTest + void should_raise_issues(SonarLintTestHarness harness, @TempDir Path baseDir) { + var inputFile = SonarLintBackendTestUtils.writeFile(baseDir, "foo.py", """ def fooBar(): `1` `1` #NOSONAR """, - false); - - List issues = new ArrayList<>(); - var configuration = AnalysisConfiguration.builder() - .setBaseDir(baseDir.toPath()) - .addInputFile(inputFile) - .addActiveRules( - new ActiveRule("python:S1542", SonarLanguage.PYTHON.name()), - new ActiveRule("python:BackticksUsage", SonarLanguage.PYTHON.name())) - .build(); - - Map> logsByLevel = new EnumMap<>(Level.class); - LogOutput logOutput = new LogOutput() { - @Override - public void log(String formattedMessage, Level level, @Nullable String stacktrace) { - logsByLevel.computeIfAbsent(level, k -> new ArrayList<>()).add(formattedMessage); - } - }; - ClientModuleFileSystem clientFileSystem = new ClientModuleFileSystem() { - @Override - public Stream files(String s, InputFile.Type type) { - return Stream.of(inputFile); - } - - @Override - public Stream files() { - return Stream.of(inputFile); - } - }; - sonarlintEngine.post(new RegisterModuleCommand(new ClientModuleInfo("myModule", clientFileSystem)), progressMonitor).get(); - var command = new AnalyzeCommand("myModule", configuration, issues::add, logOutput); - sonarlintEngine.post(command, progressMonitor).get(); - - assertThat(logsByLevel.get(Level.WARN)).containsExactly("No workDir in SonarLint"); - assertThat(issues).extracting("ruleKey", "textRange.startLine", "inputFile.path").containsOnly( - tuple("python:BackticksUsage", 2, inputFile.uri().getPath()), - tuple("python:S1542", 1, inputFile.uri().getPath())); - } - - private static ClientInputFile prepareInputFile(String relativePath, String content, final boolean isTest) throws IOException { - File file = new File(baseDir, relativePath); - FileUtils.write(file, content, StandardCharsets.UTF_8); - return createInputFile(file.toPath(), relativePath, isTest); - } - - private static ClientInputFile createInputFile(final Path path, String relativePath, final boolean isTest) { - return new ClientInputFile() { - - @Override - public String getPath() { - return path.toString(); - } - - @Override - public boolean isTest() { - return isTest; - } - - @Override - public Charset getCharset() { - return StandardCharsets.UTF_8; - } - - @Override - public G getClientObject() { - return null; - } - - @Override - public InputStream inputStream() throws IOException { - return Files.newInputStream(path); - } - - @Override - public String contents() throws IOException { - return new String(Files.readAllBytes(path), StandardCharsets.UTF_8); - } - - @Override - public String relativePath() { - return relativePath; - } - - @Override - public URI uri() { - return path.toUri(); - } - - }; + Language.PYTHON); + + var client = SonarLintBackendTestUtils.createClient(harness, baseDir, inputFile); + var backend = SonarLintBackendTestUtils.startBackend( + harness, + client, + Set.of(Language.PYTHON), + Set.of("python:S1542", "python:BackticksUsage")); + + SonarLintBackendTestUtils.openFile(backend, inputFile); + + SonarLintBackendTestUtils.awaitIssues(client, issuesByUri -> assertThat( + issuesByUri.entrySet().stream() + .flatMap(entry -> entry.getValue().stream() + .map(issue -> tuple(issue.getRuleKey(), issue.getTextRange().getStartLine(), entry.getKey()))) + .toList()) + .containsExactlyInAnyOrder( + tuple("python:BackticksUsage", 2, inputFile.getUri()), + tuple("python:S1542", 1, inputFile.getUri()))); } } diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/TestReportTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/TestReportTest.java index b0bcdde8cf..2a33f89561 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/TestReportTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/TestReportTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/TestRulesTest.java b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/TestRulesTest.java index edb85d10e8..f4c671c5fd 100644 --- a/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/TestRulesTest.java +++ b/its/plugin/it-python-plugin-test/src/test/java/com/sonar/python/it/plugin/TestRulesTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -20,6 +20,7 @@ import com.sonar.python.it.ConcurrentOrchestratorExtension; import com.sonar.python.it.TestsUtils; import java.io.File; +import java.util.Comparator; import java.util.List; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; @@ -38,13 +39,14 @@ public class TestRulesTest { private static final String PROJECT_KEY = "test-rules"; private static final String PROJECT_NAME = "Test Rules"; - private static SonarScanner BUILD; - @BeforeAll static void prepare() { orchestrator.getServer().provisionProject(PROJECT_KEY, PROJECT_NAME); orchestrator.getServer().associateProjectToQualityProfile(PROJECT_KEY, "py", "python-test-rules-profile"); - BUILD = orchestrator.createSonarScanner() + } + + private SonarScanner newBuild() { + return orchestrator.createSonarScanner() .setProjectDir(new File("projects/test_code")) .setProjectKey(PROJECT_KEY) .setProjectName(PROJECT_NAME) @@ -53,9 +55,9 @@ static void prepare() { @Test void test_rules_run_on_test_files() { - BUILD.setSourceDirs("src") - .setTestDirs("tests"); - orchestrator.executeBuild(BUILD); + orchestrator.executeBuild(newBuild() + .setSourceDirs("src") + .setTestDirs("tests")); List assertOnTupleIssues = issues("python:S5905"); List dedicatedAssertionIssues = issues("python:S5906"); @@ -70,9 +72,12 @@ void test_rules_run_on_test_files() { } @Test - void declare_all_files_as_test_files() { - BUILD.setTestDirs("."); - orchestrator.executeBuild(BUILD); + void main_rules_suppressed_when_all_files_declared_as_test() { + // main_src/ is an empty placeholder so sonar.sources points to a valid path with no Python files. + // All actual Python files are under sonar.tests=src,tests → classified as TEST → S3923 (MAIN-scoped) fires nowhere. + orchestrator.executeBuild(newBuild() + .setSourceDirs("main_src") + .setTestDirs("src,tests")); List testRuleIssues = issues("python:S5905"); List mainRuleIssues = issues("python:S3923"); @@ -81,6 +86,69 @@ void declare_all_files_as_test_files() { assertThat(mainRuleIssues).isEmpty(); } + @Test + void auto_detect_test_files_when_sonar_tests_not_configured() { + // When sonar.tests is not set, all files get InputFile.Type.MAIN from the platform. + // The plugin's path-based heuristic detects files in the `tests/` directory and + // suppresses MAIN-scoped rules on them, while CheckScope.ALL and TEST-scoped rules still fire. + orchestrator.executeBuild(newBuild() + .setProperty("sonar.sources", "src,tests")); // all files are MAIN — no sonar.tests configured + + List mainRuleIssues = issues("python:S3923"); + List allFilesRuleIssues = issues("python:S5905"); + List testScopedRuleIssues = issues("python:S5906"); + + // S3923 (MAIN-scoped): fires only on src/some_code.py; heuristic silences it on tests/ + assertThat(mainRuleIssues).hasSize(1); + assertIssue(mainRuleIssues.get(0), 3, + "Remove this if statement or edit its code blocks so that they're not all the same.", + "test-rules:src/some_code.py"); + + // S5905 (CheckScope.ALL): fires on both files regardless of effective type + assertThat(allFilesRuleIssues).hasSize(2); + assertIssue(allFilesRuleIssues.get(0), 2, + "Fix this assertion on a tuple literal.", "test-rules:src/some_code.py"); + assertIssue(allFilesRuleIssues.get(1), 3, + "Fix this assertion on a tuple literal.", "test-rules:tests/test_my_code.py"); + + // S5906 (TEST-scoped): fires on heuristic-detected test file + assertThat(testScopedRuleIssues).hasSize(1); + assertIssue(testScopedRuleIssues.get(0), 14, + "Consider using \"assertEqual\" instead.", "test-rules:tests/test_my_code.py"); + } + + @Test + void sonar_tests_configured_bypasses_heuristic() { + // When sonar.tests is explicitly configured, the path-based heuristic is inactive. + // Platform typing governs: files under tests/ are TEST because sonar.tests=tests. + // Setting sonar.tests is the recommended approach — it gives explicit, predictable + // control and produces the same isolation as the heuristic. + orchestrator.executeBuild(newBuild() + .setProperty("sonar.sources", "src") + .setProperty("sonar.tests", "tests")); + + List mainRuleIssues = issues("python:S3923"); + List allFilesRuleIssues = issues("python:S5905"); + List testScopedRuleIssues = issues("python:S5906"); + + // S3923 (MAIN-scoped): tests/ files are TEST by platform typing — same suppression as heuristic + assertThat(mainRuleIssues).hasSize(1); + assertIssue(mainRuleIssues.get(0), 3, + "Remove this if statement or edit its code blocks so that they're not all the same.", + "test-rules:src/some_code.py"); + + assertThat(allFilesRuleIssues).hasSize(2); + assertIssue(allFilesRuleIssues.get(0), 2, + "Fix this assertion on a tuple literal.", "test-rules:src/some_code.py"); + assertIssue(allFilesRuleIssues.get(1), 3, + "Fix this assertion on a tuple literal.", "test-rules:tests/test_my_code.py"); + + // S5906 (TEST-scoped): fires on the explicit test file + assertThat(testScopedRuleIssues).hasSize(1); + assertIssue(testScopedRuleIssues.get(0), 14, + "Consider using \"assertEqual\" instead.", "test-rules:tests/test_my_code.py"); + } + private void assertIssue(Issues.Issue issue, int expectedLine, String expectedMessage, String expectedComponent) { assertThat(issue.getLine()).isEqualTo(expectedLine); assertThat(issue.getMessage()).isEqualTo(expectedMessage); @@ -88,6 +156,9 @@ private void assertIssue(Issues.Issue issue, int expectedLine, String expectedMe } private static List issues(String rulekey) { - return newWsClient().issues().search(new SearchRequest().setRules(singletonList(rulekey))).getIssuesList(); + return newWsClient().issues().search(new SearchRequest().setRules(singletonList(rulekey))).getIssuesList() + .stream() + .sorted(Comparator.comparing(Issues.Issue::getComponent).thenComparingInt(Issues.Issue::getLine)) + .toList(); } } diff --git a/its/plugin/pom.xml b/its/plugin/pom.xml index d257012f3b..44090d7069 100644 --- a/its/plugin/pom.xml +++ b/its/plugin/pom.xml @@ -5,7 +5,7 @@ org.sonarsource.python python-its - 5.19-SNAPSHOT + 5.30.0.36259 diff --git a/its/plugin/python-custom-rules-plugin/pom.xml b/its/plugin/python-custom-rules-plugin/pom.xml index 1aef6254e1..e9b8d223c4 100644 --- a/its/plugin/python-custom-rules-plugin/pom.xml +++ b/its/plugin/python-custom-rules-plugin/pom.xml @@ -6,7 +6,7 @@ org.sonarsource.python it-python-plugin - 5.19-SNAPSHOT + 5.30.0.36259 python-custom-rules-plugin @@ -21,8 +21,8 @@ sonar-plugin-api - org.sonarsource.sonarqube - sonar-plugin-api-impl + org.sonarsource.scanner.engine + sensor-test-fixtures test @@ -67,8 +67,8 @@ maven-compiler-plugin - 1.8 - 1.8 + 21 + 21 diff --git a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonRuleRepository.java b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonRuleRepository.java index 5bd25dab40..71f7cb9d06 100644 --- a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonRuleRepository.java +++ b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonRuleRepository.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonRulesPlugin.java b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonRulesPlugin.java index 68545fe5d1..a4b833f584 100644 --- a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonRulesPlugin.java +++ b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonRulesPlugin.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonSubscriptionCheck.java b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonSubscriptionCheck.java index aa8aab2aea..b911d30820 100644 --- a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonSubscriptionCheck.java +++ b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonSubscriptionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonVisitorCheck.java b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonVisitorCheck.java index 3263e0b524..1d0d31484d 100644 --- a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonVisitorCheck.java +++ b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/CustomPythonVisitorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/package-info.java b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/package-info.java index e8c0598fe2..6c7478ff3b 100644 --- a/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/package-info.java +++ b/its/plugin/python-custom-rules-plugin/src/main/java/org/sonar/samples/python/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonRuleRepositoryTest.java b/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonRuleRepositoryTest.java index fbbebfbe04..d9dddbfc09 100644 --- a/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonRuleRepositoryTest.java +++ b/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonRuleRepositoryTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonRulesPluginTest.java b/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonRulesPluginTest.java index 1230c0e0c4..f6372934fd 100644 --- a/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonRulesPluginTest.java +++ b/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonRulesPluginTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,13 +16,12 @@ */ package org.sonar.samples.python; +import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime; import org.junit.jupiter.api.Test; import org.sonar.api.Plugin; import org.sonar.api.SonarEdition; import org.sonar.api.SonarQubeSide; import org.sonar.api.SonarRuntime; -import org.sonar.api.internal.PluginContextImpl; -import org.sonar.api.internal.SonarRuntimeImpl; import org.sonar.api.utils.Version; import static org.assertj.core.api.Assertions.assertThat; @@ -30,8 +29,8 @@ class CustomPythonRulesPluginTest { @Test void test() { - SonarRuntime sonarRuntime = SonarRuntimeImpl.forSonarQube(Version.create(7, 9), SonarQubeSide.SCANNER, SonarEdition.DEVELOPER); - Plugin.Context context = new PluginContextImpl.Builder().setSonarRuntime(sonarRuntime).build(); + SonarRuntime sonarRuntime = TestSonarRuntime.forSonarQube(Version.create(7, 9), SonarQubeSide.SCANNER, SonarEdition.DEVELOPER); + Plugin.Context context = new Plugin.Context(sonarRuntime); new CustomPythonRulesPlugin().define(context); assertThat(context.getExtensions()).hasSize(1); } diff --git a/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonSubscriptionCheckTest.java b/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonSubscriptionCheckTest.java index 8510a2bdd1..3575192e4a 100644 --- a/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonSubscriptionCheckTest.java +++ b/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonSubscriptionCheckTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonVisitorCheckTest.java b/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonVisitorCheckTest.java index c320154949..f432c1db43 100644 --- a/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonVisitorCheckTest.java +++ b/its/plugin/python-custom-rules-plugin/src/test/java/org/sonar/samples/python/CustomPythonVisitorCheckTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2012-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/its/pom.xml b/its/pom.xml index b990c17944..76173df1de 100644 --- a/its/pom.xml +++ b/its/pom.xml @@ -5,7 +5,7 @@ org.sonarsource.python python - 5.19-SNAPSHOT + 5.30-SNAPSHOT python-its diff --git a/mise.ci.toml b/mise.ci.toml new file mode 100644 index 0000000000..121a8ee375 --- /dev/null +++ b/mise.ci.toml @@ -0,0 +1,4 @@ +[settings] +# Keep tox in base mise.toml for local development, but skip mise-managed tox +# in CI and install it explicitly via uv where needed. +disable_tools = ["pipx:tox"] diff --git a/mise.test-and-analyze.toml b/mise.test-and-analyze.toml index a040730e94..6086b56320 100644 --- a/mise.test-and-analyze.toml +++ b/mise.test-and-analyze.toml @@ -1,2 +1,2 @@ [tools] -java = "17.0" +java = "21.0" diff --git a/mise.toml b/mise.toml index 5da6bd7b23..3e7762f1b6 100644 --- a/mise.toml +++ b/mise.toml @@ -3,4 +3,4 @@ java = "21.0" maven = "3.9" python = "3.9" uv = "latest" # required for pipx backend -"pipx:tox" = { version = "latest", uvx = "true" } +"pipx:tox" = { version = "4.60.0", uvx = "true" } diff --git a/override-dep-licenses.properties b/override-dep-licenses.properties index a29c0aa366..9b5b7c5490 100644 --- a/override-dep-licenses.properties +++ b/override-dep-licenses.properties @@ -4,4 +4,4 @@ com.google.code.gson--gson--2.11.0=apache_v2 commons-io--commons-io--2.17.0=apache_v2 com.github.spotbugs=apache_v2 info.picocli--picocli--4.7.5=apache_v2 -org.codehaus.woodstox--stax2-api--4.2.2=bsd +org.codehaus.woodstox--stax2-api--4.3.0=bsd diff --git a/pom.xml b/pom.xml index 4b455dbe9f..bd9c9b3631 100644 --- a/pom.xml +++ b/pom.xml @@ -5,12 +5,12 @@ org.sonarsource.parent parent - 86.0.0.3040 + 87.0.0.3057 org.sonarsource.python python - 5.19-SNAPSHOT + 5.30-SNAPSHOT pom Python @@ -86,41 +86,43 @@ false - 2.21.0 + 2.22.0 3.20.0 1.15.0 3.27.7 - 6.0.2 - 1.5.27 - 2.0.17 + 6.1.3 + 1.6.3 + 2.0.18 2.2.1 - 5.21.0 + 5.23.0 Python Enterprise - 26.2.0.119303 - 13.0.0.3026 - 6.1.0.3962 - 2.21.0.4626 + 26.8.0.126808 + 13.11.0.4459 + 13.8.0.4534 + 6.4.2.4626 + 2.30.0.5193 its/**,private/its-enterprise/**,python-frontend/typeshed_serializer/**,**/test/resources/** - 10.13.0.79996 - 1.25.1.3886 - 4.29.0 + 11.9.0.86162 + 1.26.0.4194 + 4.29.3 6.2.7 - 2.13.2 - 2.21.0 + 2.14.0 + 2.22.1 + 2.29.0.6136 - 11 + 21 - 17 - 17 - 17 + 21 + 21 + 21 @@ -203,7 +205,7 @@ com.google.guava guava - 33.5.0-jre + 33.6.0-jre com.fasterxml.jackson.core @@ -234,6 +236,18 @@ ${sonar.version} test + + org.sonarsource.scanner.engine + plugin-api-scanner-impl + ${scanner-engine.version} + test + + + org.sonarsource.scanner.engine + sensor-test-fixtures + ${scanner-engine.version} + test + org.sonarsource.sslr sslr-testing-harness @@ -255,7 +269,7 @@ org.junit.platform junit-platform-suite-engine - 6.0.2 + 6.1.3 test @@ -288,12 +302,6 @@ ${logback.version} test - - org.sonarsource.sonarqube - sonar-plugin-api-impl - ${sonar.version} - test - org.sonarsource.api.plugin sonar-plugin-api-test-fixtures @@ -322,6 +330,11 @@ true + + org.codehaus.mojo + exec-maven-plugin + 3.6.3 + diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000000..c641501204 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,4 @@ +[[tool.uv.index]] +name = "repox" +url = "https://repox.jfrog.io/artifactory/api/pypi/sonarsource-pypi/simple" +default = true diff --git a/python-checks-testkit/pom.xml b/python-checks-testkit/pom.xml index d6e3bdf449..1ea9069f98 100644 --- a/python-checks-testkit/pom.xml +++ b/python-checks-testkit/pom.xml @@ -6,7 +6,7 @@ python org.sonarsource.python - 5.19-SNAPSHOT + 5.30-SNAPSHOT python-checks-testkit diff --git a/python-checks-testkit/src/main/java/org/sonar/python/checks/quickfix/PythonQuickFixVerifier.java b/python-checks-testkit/src/main/java/org/sonar/python/checks/quickfix/PythonQuickFixVerifier.java index 9684118fd4..ddf0895fba 100644 --- a/python-checks-testkit/src/main/java/org/sonar/python/checks/quickfix/PythonQuickFixVerifier.java +++ b/python-checks-testkit/src/main/java/org/sonar/python/checks/quickfix/PythonQuickFixVerifier.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,12 +16,14 @@ */ package org.sonar.python.checks.quickfix; +import java.io.File; import java.net.URI; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List; +import java.util.Map; import java.util.function.Function; import java.util.stream.Stream; import org.sonar.api.SonarProduct; @@ -33,6 +35,7 @@ import org.sonar.plugins.python.api.quickfix.PythonQuickFix; import org.sonar.plugins.python.api.quickfix.PythonTextEdit; import org.sonar.python.SubscriptionVisitor; +import org.sonar.python.TestPythonVisitorRunner; import org.sonar.python.caching.CacheContextImpl; import org.sonar.python.parser.PythonParser; import org.sonar.python.semantic.ProjectLevelSymbolTable; @@ -41,8 +44,11 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatCode; +import static org.sonar.python.semantic.SymbolUtils.pythonPackageName; public class PythonQuickFixVerifier { + private static final String SEMANTIC_BASE_DIR = new File("target/pythonQuickFixVerifier").getAbsolutePath(); + private PythonQuickFixVerifier() { } @@ -58,6 +64,18 @@ public static void verifyQuickFixMessages(PythonCheck check, String codeWithIssu verifyQuickFixMessages(PythonQuickFixVerifier::createPythonVisitorContext, check, codeWithIssue, expectedMessages); } + public static void verifySemantic(PythonCheck check, String path, String codeWithIssue, String... codesFixed) { + verify(code -> createSemanticVisitorContext(path, code), check, false, codeWithIssue, codesFixed); + } + + public static void verifySemanticQuickFixMessages(PythonCheck check, String path, String codeWithIssue, String... expectedMessages) { + verifyQuickFixMessages(code -> createSemanticVisitorContext(path, code), check, codeWithIssue, expectedMessages); + } + + public static void verifySemanticNoQuickFixes(PythonCheck check, String path, String codeWithIssue) { + verifyNoQuickFixes(code -> createSemanticVisitorContext(path, code), check, codeWithIssue); + } + public static void verifyIPython(PythonCheck check, String codeWithIssue, String... codesFixed) { verify(PythonQuickFixVerifier::createIPythonVisitorContext, check, true, codeWithIssue, codesFixed); } @@ -154,6 +172,14 @@ private static PythonVisitorContext createIPythonVisitorContext(String code) { return createVisitorContext(PythonParser.createIPythonParser(), new IPythonTreeMaker(), code); } + private static PythonVisitorContext createSemanticVisitorContext(String path, String code) { + var pythonFile = new TestPythonVisitorRunner.MockPythonFile(SEMANTIC_BASE_DIR, path, code); + List packageRoots = TestPythonVisitorRunner.computePackageRoots(List.of(pythonFile.file()), new File(SEMANTIC_BASE_DIR)); + ProjectLevelSymbolTable globalSymbols = TestPythonVisitorRunner.globalSymbols(Map.of(path, code), SEMANTIC_BASE_DIR, packageRoots); + String packageName = pythonPackageName(pythonFile.file(), packageRoots); + return TestPythonVisitorRunner.createContext(pythonFile, null, packageName, globalSymbols, CacheContextImpl.dummyCache()); + } + private static PythonVisitorContext createVisitorContext(PythonParser parser, PythonTreeMaker treeMaker, String code) { var pythonFile = new PythonQuickFixFile(code); var astNode = parser.parse(pythonFile.content()); @@ -206,30 +232,34 @@ private static void checkNoCollision(List pythonTextEdits) throw // we should return false private static boolean oneEnclosedByTheOther(PythonTextEdit toCheck, PythonTextEdit reference) { if (onSameLine(toCheck, reference)) { - // If on same line, we need to check that the bounds of toCheck are not contained in reference bounds - return !(toCheck.endLineOffset() < reference.startLineOffset() || toCheck.startLineOffset() > reference.endLineOffset()); - } else { - if (compactOnDifferentLines(toCheck, reference)) { - return false; - } else if (isCompact(toCheck)) { - return isSecondInFirst(toCheck, reference); - } else if (isCompact(reference)) { - return isSecondInFirst(reference, toCheck); - } else { - // Both edits exploded on different lines - if (noLineIntersection(toCheck, reference)) { - return false; - } else { - // There is an intersection between edits, only need to check valid case - if (reference.startLine() == toCheck.endLine()) { - return toCheck.endLineOffset() > reference.startLineOffset(); - } else if (reference.endLine() == toCheck.startLine()) { - return reference.endLineOffset() > toCheck.startLineOffset(); - } - } - } + return sameLineIntersection(toCheck, reference); + } + if (compactOnDifferentLines(toCheck, reference)) { + return false; + } + if (isCompact(toCheck)) { + return isSecondInFirst(toCheck, reference); + } + if (isCompact(reference)) { + return isSecondInFirst(reference, toCheck); + } + return explodedEditsIntersect(toCheck, reference); + } + + private static boolean sameLineIntersection(PythonTextEdit toCheck, PythonTextEdit reference) { + return !(toCheck.endLineOffset() < reference.startLineOffset() || toCheck.startLineOffset() > reference.endLineOffset()); + } + + private static boolean explodedEditsIntersect(PythonTextEdit toCheck, PythonTextEdit reference) { + if (noLineIntersection(toCheck, reference)) { + return false; + } + if (reference.startLine() == toCheck.endLine()) { + return toCheck.endLineOffset() > reference.startLineOffset(); + } + if (reference.endLine() == toCheck.startLine()) { + return reference.endLineOffset() > toCheck.startLineOffset(); } - // All other cases are invalid and will cause an intersection return true; } diff --git a/python-checks-testkit/src/main/java/org/sonar/python/checks/quickfix/package-info.java b/python-checks-testkit/src/main/java/org/sonar/python/checks/quickfix/package-info.java index 5f9c664a20..dd94520362 100644 --- a/python-checks-testkit/src/main/java/org/sonar/python/checks/quickfix/package-info.java +++ b/python-checks-testkit/src/main/java/org/sonar/python/checks/quickfix/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/PythonCheckVerifier.java b/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/PythonCheckVerifier.java index 9e7bc4d36c..e6e562ec95 100644 --- a/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/PythonCheckVerifier.java +++ b/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/PythonCheckVerifier.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -58,7 +58,7 @@ public static void verify(String path, PythonCheck check) { public static void verifyNoIssue(String path, PythonCheck check) { File file = new File(path); - createVerifier(Collections.singletonList(file), check, ProjectLevelSymbolTable.empty(), null, null) + createVerifier(Collections.singletonList(file), check, ProjectLevelSymbolTable.empty(), List.of(), null) .assertNoIssues(); } @@ -69,31 +69,33 @@ public static void verify(List paths, PythonCheck check) { public static void verify(List paths, PythonCheck check, @Nullable ProjectConfiguration projectConfiguration) { List files = paths.stream().map(File::new).toList(); File baseDirFile = new File(files.get(0).getParent()); - ProjectLevelSymbolTable projectLevelSymbolTable = TestPythonVisitorRunner.globalSymbols(files, baseDirFile); - createVerifier(files, check, projectLevelSymbolTable, baseDirFile, projectConfiguration).assertOneOrMoreIssues(); + List packageRoots = TestPythonVisitorRunner.computePackageRoots(files, baseDirFile); + ProjectLevelSymbolTable projectLevelSymbolTable = TestPythonVisitorRunner.globalSymbols(files, packageRoots); + createVerifier(files, check, projectLevelSymbolTable, packageRoots, projectConfiguration).assertOneOrMoreIssues(); } public static void verifyNoIssue(List paths, PythonCheck check) { List files = paths.stream().map(File::new).toList(); File baseDirFile = new File(files.get(0).getParent()); - ProjectLevelSymbolTable projectLevelSymbolTable = TestPythonVisitorRunner.globalSymbols(files, baseDirFile); - createVerifier(files, check, projectLevelSymbolTable, baseDirFile, null).assertNoIssues(); + List packageRoots = TestPythonVisitorRunner.computePackageRoots(files, baseDirFile); + ProjectLevelSymbolTable projectLevelSymbolTable = TestPythonVisitorRunner.globalSymbols(files, packageRoots); + createVerifier(files, check, projectLevelSymbolTable, packageRoots, null).assertNoIssues(); } public static List issues(String path, PythonCheck check) { File file = new File(path); - PythonVisitorContext context = createContext(file, ProjectLevelSymbolTable.empty(), null, null); + PythonVisitorContext context = createContext(file, ProjectLevelSymbolTable.empty(), null, List.of()); return scanFileForIssues(check, context); } private static MultiFileVerifier createVerifier(List files, PythonCheck check, ProjectLevelSymbolTable projectLevelSymbolTable, - @Nullable File baseDir, + List packageRoots, @Nullable ProjectConfiguration projectConfiguration) { MultiFileVerifier multiFileVerifier = MultiFileVerifier.create(files.get(0).toPath(), UTF_8); for (File file : files) { - PythonVisitorContext context = createContext(file, projectLevelSymbolTable, projectConfiguration, baseDir); + PythonVisitorContext context = createContext(file, projectLevelSymbolTable, projectConfiguration, packageRoots); addFileIssues(check, multiFileVerifier, file, context); } return multiFileVerifier; @@ -102,11 +104,11 @@ private static MultiFileVerifier createVerifier(List files, private static PythonVisitorContext createContext(File file, ProjectLevelSymbolTable projectLevelSymbolTable, @Nullable ProjectConfiguration projectConfiguration, - @Nullable File baseDir) { - return baseDir != null + List packageRoots) { + return !packageRoots.isEmpty() ? TestPythonVisitorRunner.createContext(file, null, - pythonPackageName(file, baseDir.getAbsolutePath()), + pythonPackageName(file, packageRoots), projectLevelSymbolTable, CacheContextImpl.dummyCache(), projectConfiguration) @@ -148,6 +150,13 @@ private static MultiFileVerifier.Issue addPreciseIssue(Path path, MultiFileVerif issueBuilder.addSecondary(path, secondary.startLine(), secondary.startLineOffset() + 1, secondary.endLine(), secondary.endLineOffset(), secondary.message()); } + // Commons verifier has no named-flow API; flatten flow locations as secondaries for sample assertions. + for (PythonCheck.IssueFlow flow : preciseIssue.flows()) { + for (IssueLocation flowLocation : flow.locations()) { + issueBuilder.addSecondary(path, flowLocation.startLine(), flowLocation.startLineOffset() + 1, + flowLocation.endLine(), flowLocation.endLineOffset(), flowLocation.message()); + } + } return issueBuilder; } diff --git a/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/PythonMultiFileVerifier.java b/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/PythonMultiFileVerifier.java index 94860bac34..47361aaac1 100644 --- a/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/PythonMultiFileVerifier.java +++ b/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/PythonMultiFileVerifier.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -21,6 +21,7 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.function.Function; import java.util.stream.Collectors; @@ -46,7 +47,10 @@ public static Map mapFiles(Map pathToCode, String var newBaseDir = getNewBaseDir(baseDir, tempDirectoryPath); - var symbolTable = TestPythonVisitorRunner.globalSymbols(pathToCode, newBaseDir); + File baseDirFile = new File(newBaseDir); + List files = pathToCode.keySet().stream().map(path -> new File(newBaseDir, path)).toList(); + List packageRoots = TestPythonVisitorRunner.computePackageRoots(files, baseDirFile); + var symbolTable = TestPythonVisitorRunner.globalSymbols(pathToCode, newBaseDir, packageRoots); Map results = new HashMap<>(); pathToFile.forEach((path, file) -> { diff --git a/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/package-info.java b/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/package-info.java index 8634f7f6de..ff19e08b7a 100644 --- a/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/package-info.java +++ b/python-checks-testkit/src/main/java/org/sonar/python/checks/utils/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks-testkit/src/test/java/org/sonar/python/checks/quickfix/PythonQuickFixVerifierTest.java b/python-checks-testkit/src/test/java/org/sonar/python/checks/quickfix/PythonQuickFixVerifierTest.java index 269fe92492..655cde2317 100644 --- a/python-checks-testkit/src/test/java/org/sonar/python/checks/quickfix/PythonQuickFixVerifierTest.java +++ b/python-checks-testkit/src/test/java/org/sonar/python/checks/quickfix/PythonQuickFixVerifierTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,6 +16,7 @@ */ package org.sonar.python.checks.quickfix; +import java.lang.reflect.Method; import org.junit.jupiter.api.Test; import org.opentest4j.AssertionFailedError; import org.sonar.plugins.python.api.PythonCheck; @@ -80,6 +81,16 @@ void test_verify() { PythonQuickFixVerifier.verify(new SimpleCheck(), "a=10", "a!=10"); } + @Test + void test_verify_no_quickfixes_wrapper() { + PythonQuickFixVerifier.verifyNoQuickFixes(new SimpleCheckNoQuickFix(), "a=10"); + } + + @Test + void test_verify_quick_fix_messages_wrapper() { + PythonQuickFixVerifier.verifyQuickFixMessages(new SimpleCheck(), "a=10", "Add '!' here."); + } + @Test void test_verify_invalid_after() { var expectedMsg = """ @@ -99,11 +110,101 @@ void verifyIPython() { PythonQuickFixVerifier.verifyIPythonQuickFixMessages(new SimpleCheck(), "a=10\n?a", "Add '!' here."); } + @Test + void verifyIPythonNoQuickFixes() { + PythonQuickFixVerifier.verifyIPythonNoQuickFixes(new SimpleCheckNoQuickFix(), "a=10\n?a"); + } + @Test void test_multiple_lines() { PythonQuickFixVerifier.verify(new SimpleCheck(), "b \na=10", "b \na!=10"); } + @Test + void verify_semantic() { + PythonQuickFixVerifier.verifySemantic(new SimpleCheck(), "pkg/test_file.py", "a=10", "a!=10"); + PythonQuickFixVerifier.verifySemanticQuickFixMessages(new SimpleCheck(), "pkg/test_file.py", "a=10", "Add '!' here."); + } + + @Test + void verify_semantic_no_quickfix() { + PythonQuickFixVerifier.verifySemanticNoQuickFixes(new SimpleCheckNoQuickFix(), "pkg/test_file.py", "a=10"); + } + + @Test + void test_multiple_text_edits_are_sorted_and_apply_on_windows_line_endings() { + PythonQuickFixVerifier.verify(new MultipleEditsCheck(), "a=10\r\nb=3", "a!=10\r\nb!=3"); + } + + @Test + void test_colliding_multiple_text_edits_fail() { + var check = new CollidingEditsCheck(); + assertThatThrownBy(() -> PythonQuickFixVerifier.verify(check, "a=10", "")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("There is a collision between the range of the quickfixes."); + } + + @Test + void collision_helpers_cover_remaining_branches() throws Exception { + Method oneEnclosedByTheOther = PythonQuickFixVerifier.class.getDeclaredMethod("oneEnclosedByTheOther", PythonTextEdit.class, PythonTextEdit.class); + Method sameLineIntersection = PythonQuickFixVerifier.class.getDeclaredMethod("sameLineIntersection", PythonTextEdit.class, PythonTextEdit.class); + Method explodedEditsIntersect = PythonQuickFixVerifier.class.getDeclaredMethod("explodedEditsIntersect", PythonTextEdit.class, PythonTextEdit.class); + Method onSameLine = PythonQuickFixVerifier.class.getDeclaredMethod("onSameLine", PythonTextEdit.class, PythonTextEdit.class); + Method compactOnDifferentLines = PythonQuickFixVerifier.class.getDeclaredMethod("compactOnDifferentLines", PythonTextEdit.class, PythonTextEdit.class); + Method isCompact = PythonQuickFixVerifier.class.getDeclaredMethod("isCompact", PythonTextEdit.class); + Method isSecondInFirst = PythonQuickFixVerifier.class.getDeclaredMethod("isSecondInFirst", PythonTextEdit.class, PythonTextEdit.class); + Method noLineIntersection = PythonQuickFixVerifier.class.getDeclaredMethod("noLineIntersection", PythonTextEdit.class, PythonTextEdit.class); + oneEnclosedByTheOther.setAccessible(true); + sameLineIntersection.setAccessible(true); + explodedEditsIntersect.setAccessible(true); + onSameLine.setAccessible(true); + compactOnDifferentLines.setAccessible(true); + isCompact.setAccessible(true); + isSecondInFirst.setAccessible(true); + noLineIntersection.setAccessible(true); + + PythonTextEdit sameLineLeft = new PythonTextEdit("", 1, 0, 1, 0); + PythonTextEdit sameLineRight = new PythonTextEdit("", 1, 1, 1, 1); + PythonTextEdit sameLineOverlap = new PythonTextEdit("", 1, 0, 1, 2); + assertBoolean(sameLineIntersection, false, sameLineLeft, sameLineRight); + assertBoolean(sameLineIntersection, true, sameLineOverlap, sameLineRight); + assertBoolean(onSameLine, true, sameLineOverlap, sameLineRight); + + PythonTextEdit compact = new PythonTextEdit("", 2, 0, 2, 1); + PythonTextEdit compactSameStart = new PythonTextEdit("", 1, 1, 1, 3); + PythonTextEdit compactSameEnd = new PythonTextEdit("", 3, 0, 3, 2); + PythonTextEdit compactOtherLine = new PythonTextEdit("", 5, 0, 5, 1); + PythonTextEdit exploded = new PythonTextEdit("", 1, 0, 3, 0); + PythonTextEdit explodedSameEnd = new PythonTextEdit("", 1, 0, 3, 3); + PythonTextEdit separate = new PythonTextEdit("", 4, 0, 5, 0); + PythonTextEdit touchingEnd = new PythonTextEdit("", 2, 1, 4, 0); + PythonTextEdit crossingEnd = new PythonTextEdit("", 2, 0, 4, 0); + PythonTextEdit touchingStart = new PythonTextEdit("", 1, 0, 2, 1); + PythonTextEdit explodedEnclosing = new PythonTextEdit("", 1, 0, 4, 0); + PythonTextEdit explodedEnclosed = new PythonTextEdit("", 2, 0, 3, 0); + + assertBoolean(compactOnDifferentLines, true, compact, compactOtherLine); + assertBoolean(isCompact, true, compact); + assertBoolean(isCompact, false, exploded); + assertBoolean(isSecondInFirst, true, compactSameStart, exploded); + assertBoolean(isSecondInFirst, true, compactSameEnd, explodedSameEnd); + assertBoolean(isSecondInFirst, false, compact, separate); + assertBoolean(noLineIntersection, true, exploded, separate); + assertBoolean(noLineIntersection, false, exploded, touchingEnd); + assertBoolean(oneEnclosedByTheOther, true, sameLineOverlap, sameLineRight); + assertBoolean(oneEnclosedByTheOther, false, compact, compactOtherLine); + assertBoolean(oneEnclosedByTheOther, true, compactSameStart, exploded); + assertBoolean(oneEnclosedByTheOther, true, explodedSameEnd, compactSameEnd); + assertBoolean(oneEnclosedByTheOther, true, explodedEnclosing, explodedEnclosed); + assertBoolean(explodedEditsIntersect, false, exploded, separate); + assertBoolean(explodedEditsIntersect, true, touchingStart, crossingEnd); + assertBoolean(explodedEditsIntersect, true, explodedEnclosing, explodedEnclosed); + } + + private static void assertBoolean(Method method, boolean expected, Object... args) throws Exception { + org.assertj.core.api.Assertions.assertThat(method.invoke(null, args)).isEqualTo(expected); + } + private class SimpleCheck extends PythonSubscriptionCheck { @Override @@ -128,4 +229,37 @@ public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.ASSIGNMENT_STMT, ctx -> ctx.addIssue(ctx.syntaxNode(), "")); } } + + private class MultipleEditsCheck extends PythonSubscriptionCheck { + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.ASSIGNMENT_STMT, ctx -> { + AssignmentStatement assignment = (AssignmentStatement) ctx.syntaxNode(); + if (assignment.firstToken().line() != 1) { + return; + } + PreciseIssue issue = ctx.addIssue(assignment.equalTokens().get(0), ""); + PythonQuickFix quickFix = PythonQuickFix.newQuickFix("Add '!' here.") + .addTextEdit(new PythonTextEdit("!", 2, 1, 2, 1)) + .addTextEdit(TextEditUtils.insertBefore(assignment.equalTokens().get(0), "!")) + .build(); + issue.addQuickFix(quickFix); + }); + } + } + + private class CollidingEditsCheck extends PythonSubscriptionCheck { + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.ASSIGNMENT_STMT, ctx -> { + AssignmentStatement assignment = (AssignmentStatement) ctx.syntaxNode(); + PreciseIssue issue = ctx.addIssue(assignment.equalTokens().get(0), ""); + PythonQuickFix quickFix = PythonQuickFix.newQuickFix("Broken quickfix") + .addTextEdit(new PythonTextEdit("!", 1, 1, 1, 1)) + .addTextEdit(new PythonTextEdit("!=", 1, 1, 1, 2)) + .build(); + issue.addQuickFix(quickFix); + }); + } + } } diff --git a/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonCheckVerifierAdditionalTest.java b/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonCheckVerifierAdditionalTest.java index 628893da92..1e0f99b913 100644 --- a/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonCheckVerifierAdditionalTest.java +++ b/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonCheckVerifierAdditionalTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonCheckVerifierTest.java b/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonCheckVerifierTest.java index dcdafe9752..2694bb8503 100644 --- a/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonCheckVerifierTest.java +++ b/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonCheckVerifierTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -28,7 +28,8 @@ import org.sonar.plugins.python.api.tree.FunctionDef; import org.sonar.plugins.python.api.tree.Tree; -import static org.assertj.core.api.Assertions.fail; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.fail; class PythonCheckVerifierTest { @@ -90,17 +91,8 @@ void subscription_test(String file, boolean expectSuccess) { } private void assertNoFailureOfVerifier(String filePath, PythonCheck check) { - try { - PythonCheckVerifier.verify(filePath, check); - } catch (AssertionError e) { - fail("should not fail", e); - } - - try { - PythonCheckVerifier.verify(Collections.singletonList(filePath), check); - } catch (AssertionError e) { - fail("should not fail", e); - } + assertDoesNotThrow(() -> PythonCheckVerifier.verify(filePath, check), "should not fail"); + assertDoesNotThrow(() -> PythonCheckVerifier.verify(Collections.singletonList(filePath), check), "should not fail"); } private static void assertFailOfVerifier(String filepath, PythonCheck check) { diff --git a/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonMultiFileVerifierTest.java b/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonMultiFileVerifierTest.java index 65f022bbd3..df3fbd7db5 100644 --- a/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonMultiFileVerifierTest.java +++ b/python-checks-testkit/src/test/java/org/sonar/python/checks/utils/PythonMultiFileVerifierTest.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -22,12 +22,13 @@ import java.nio.file.Path; import java.util.Map; import org.junit.jupiter.api.Test; -import org.mockito.Mockito; import org.sonar.plugins.python.api.PythonVisitorContext; import org.sonar.plugins.python.api.types.v2.ModuleType; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.mockStatic; class PythonMultiFileVerifierTest { @@ -56,7 +57,7 @@ void newBaseDirNotEmpty() { @Test void createTemporaryDirectorException() { - try (var files = Mockito.mockStatic(Files.class)) { + try (var files = mockStatic(Files.class)) { files.when(() -> Files.createTempDirectory("")) .thenThrow(IOException.class); @@ -69,8 +70,8 @@ void createTemporaryDirectorException() { void writeTempFileException() { var entry = Map.entry("foo.py", "class Foo: ..."); var tempDirectoryPath = Path.of("temp"); - try (var files = Mockito.mockStatic(Files.class)) { - files.when(() -> Files.newBufferedWriter(Mockito.any())) + try (var files = mockStatic(Files.class)) { + files.when(() -> Files.newBufferedWriter(any())) .thenThrow(IOException.class); assertThatThrownBy(() -> PythonMultiFileVerifier.writeTempFile(entry, tempDirectoryPath)) diff --git a/python-checks/pom.xml b/python-checks/pom.xml index 839411991f..4ab337440f 100644 --- a/python-checks/pom.xml +++ b/python-checks/pom.xml @@ -5,7 +5,7 @@ org.sonarsource.python python - 5.19-SNAPSHOT + 5.30-SNAPSHOT python-checks @@ -26,6 +26,10 @@ commons-io commons-io + + org.apache.commons + commons-text + com.google.code.gson gson @@ -73,4 +77,139 @@ + + + updateRule + + + rule.id + + + + master + + + + + org.apache.maven.plugins + maven-dependency-plugin + + + download-rule-api + generate-resources + + copy + + + + + com.sonarsource.rule-api + rule-api + ${rule.api.version} + jar + ${project.build.directory} + rule-api.jar + + + + + + + + org.codehaus.mojo + exec-maven-plugin + + + run-rule-api + generate-resources + + exec + + + java + ${project.basedir}/.. + + -jar + ${project.build.directory}/rule-api.jar + generate + -rule + ${rule.id} + -branch + ${rule.branch} + + + ${env.RULE_API_GH_TOKEN} + + + + + + + + + + updateAllRules + + + update.rules + true + + + + + + org.apache.maven.plugins + maven-dependency-plugin + + + download-rule-api-all + generate-resources + + copy + + + + + com.sonarsource.rule-api + rule-api + ${rule.api.version} + jar + ${project.build.directory} + rule-api.jar + + + + + + + + org.codehaus.mojo + exec-maven-plugin + + + run-rule-api-all + generate-resources + + exec + + + java + ${project.basedir}/.. + + -jar + ${project.build.directory}/rule-api.jar + update + + + ${env.RULE_API_GH_TOKEN} + + + + + + + + + + diff --git a/python-checks/src/main/java/org/sonar/python/checks/AbstractCallExpressionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AbstractCallExpressionCheck.java index 3f592f7f1d..91111a4401 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AbstractCallExpressionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AbstractCallExpressionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AbstractDuplicateKeyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AbstractDuplicateKeyCheck.java index 482a793fe5..24e5757730 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AbstractDuplicateKeyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AbstractDuplicateKeyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AbstractFunctionNameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AbstractFunctionNameCheck.java index d44c31cf3f..93447dcfc7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AbstractFunctionNameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AbstractFunctionNameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AbstractNameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AbstractNameCheck.java index 1acaa53c23..4039b839aa 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AbstractNameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AbstractNameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AbstractStringFormatCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AbstractStringFormatCheck.java index ff0c382ff1..ddabbe786a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AbstractStringFormatCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AbstractStringFormatCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AbstractUnreadPrivateMembersCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AbstractUnreadPrivateMembersCheck.java index 62976e8497..3c770b0242 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AbstractUnreadPrivateMembersCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AbstractUnreadPrivateMembersCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AfterJumpStatementCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AfterJumpStatementCheck.java index 125108e79d..04e13a6e29 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AfterJumpStatementCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AfterJumpStatementCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -39,13 +39,13 @@ public void initialize(Context context) { context.registerSyntaxNodeConsumer(Kind.FILE_INPUT, ctx -> { FileInput fileInput = (FileInput) ctx.syntaxNode(); - checkCfg(ControlFlowGraph.build(fileInput, ctx.pythonFile()), ctx, fileInput.statements()); + checkCfg(ctx.cfg(fileInput), ctx, fileInput.statements()); } ); context.registerSyntaxNodeConsumer(Kind.FUNCDEF, ctx -> { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); - checkCfg(ControlFlowGraph.build(functionDef, ctx.pythonFile()), ctx, functionDef.body()); + checkCfg(ctx.cfg(functionDef), ctx, functionDef.body()); } ); diff --git a/python-checks/src/main/java/org/sonar/python/checks/AllBranchesAreIdenticalCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AllBranchesAreIdenticalCheck.java index 1aaf70bcfc..b6c16ac207 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AllBranchesAreIdenticalCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AllBranchesAreIdenticalCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ArgumentNumberCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ArgumentNumberCheck.java index 43443cdf59..930d1863ea 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ArgumentNumberCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ArgumentNumberCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ArgumentTypeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ArgumentTypeCheck.java index 76e57db0d7..1c66936e5a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ArgumentTypeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ArgumentTypeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AsyncAwsLambdaHandlerCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AsyncAwsLambdaHandlerCheck.java index 29123d750e..699a27446d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AsyncAwsLambdaHandlerCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AsyncAwsLambdaHandlerCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AsyncFunctionNotAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AsyncFunctionNotAsyncCheck.java index cfaba0e560..c2c60a4f12 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AsyncFunctionNotAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AsyncFunctionNotAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,20 +16,32 @@ */ package org.sonar.python.checks; +import java.util.List; +import java.util.Set; import javax.annotation.Nullable; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.TriBool; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; import org.sonar.plugins.python.api.tree.AwaitExpression; import org.sonar.plugins.python.api.tree.BaseTreeVisitor; +import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.ComprehensionFor; +import org.sonar.plugins.python.api.tree.DictionaryLiteral; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; import org.sonar.plugins.python.api.tree.ForStatement; import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.KeyValuePair; +import org.sonar.plugins.python.api.tree.ListLiteral; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.ReturnStatement; import org.sonar.plugins.python.api.tree.Statement; import org.sonar.plugins.python.api.tree.StatementList; +import org.sonar.plugins.python.api.tree.StringLiteral; import org.sonar.plugins.python.api.tree.Token; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.WithStatement; @@ -37,30 +49,31 @@ import org.sonar.plugins.python.api.tree.YieldStatement; import org.sonar.plugins.python.api.types.v2.ClassType; import org.sonar.plugins.python.api.types.v2.FunctionType; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.utils.CheckUtils; -import org.sonar.python.types.v2.TypeCheckBuilder; +import org.sonar.python.tree.TreeUtils; @Rule(key = "S7503") public class AsyncFunctionNotAsyncCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Use asynchronous features in this function or remove the `async` keyword."; - private TypeCheckBuilder notImplementedTypeChecker; + private static final Set AIO_CONSUMER_SUBSCRIBE_CALLBACK_KWARGS = Set.of("on_assign", "on_revoke", "on_lost"); + + private static final TypeMatcher NOT_IMPLEMENTED_MATCHER = TypeMatchers.isType("builtins.NotImplemented"); + private static final TypeMatcher HTTPX_ASYNC_CLIENT_MATCHER = TypeMatchers.isOrExtendsType("httpx.AsyncClient"); + private static final TypeMatcher AIO_CONSUMER_SUBSCRIBE_MATCHER = TypeMatchers.isType("confluent_kafka.aio.AIOConsumer.subscribe"); @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, this::setupTypeChecks); - context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, this::checkAsyncFunction); - } - - private void setupTypeChecks(SubscriptionContext ctx) { - notImplementedTypeChecker = ctx.typeChecker().typeCheckBuilder().isTypeWithName("NotImplemented"); + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, AsyncFunctionNotAsyncCheck::checkAsyncFunction); } - private void checkAsyncFunction(SubscriptionContext ctx) { + private static void checkAsyncFunction(SubscriptionContext ctx) { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); Token asyncKeyword = functionDef.asyncKeyword(); - if (asyncKeyword == null || isException(functionDef)) { + if (asyncKeyword == null || isException(functionDef, ctx)) { return; } AsyncFeatureVisitor visitor = new AsyncFeatureVisitor(); @@ -71,12 +84,67 @@ private void checkAsyncFunction(SubscriptionContext ctx) { } } - private boolean isException(FunctionDef functionDef) { + private static boolean isException(FunctionDef functionDef, SubscriptionContext ctx) { return CheckUtils.isAbstract(functionDef) || - isTrivialFunction(functionDef.body()) || + isTrivialFunction(functionDef.body(), ctx) || isDunderMethod(functionDef) || !functionDef.decorators().isEmpty() || - mightBeOverridingMethod(functionDef); + mightBeOverridingMethod(functionDef) || + isExemptedCoroutineCallback(functionDef, ctx); + } + + private static boolean isExemptedCoroutineCallback(FunctionDef functionDef, SubscriptionContext ctx) { + SymbolV2 symbol = functionDef.name().symbolV2(); + if (symbol == null) { + return false; + } + return symbol.usages().stream() + .filter(usage -> usage.kind() == UsageV2.Kind.OTHER) + .anyMatch(usage -> isCoroutineCallbackUsage(usage.tree(), ctx)); + } + + private static boolean isCoroutineCallbackUsage(Tree usageTree, SubscriptionContext ctx) { + return isHttpxAsyncClientEventHookCallback(usageTree, ctx) || isAioConsumerSubscribeCallback(usageTree, ctx); + } + + private static boolean isHttpxAsyncClientEventHookCallback(Tree usageTree, SubscriptionContext ctx) { + CallExpression call = TreeUtils.firstAncestorOfClass(usageTree, CallExpression.class); + if (call == null || !HTTPX_ASYNC_CLIENT_MATCHER.isTrueFor(call.callee(), ctx)) { + return false; + } + RegularArgument eventHooksArg = TreeUtils.argumentByKeyword("event_hooks", call.arguments()); + if (eventHooksArg == null || !(eventHooksArg.expression() instanceof DictionaryLiteral dict)) { + return false; + } + return dict.elements().stream() + .filter(KeyValuePair.class::isInstance) + .map(KeyValuePair.class::cast) + .filter(kv -> isRequestOrResponseKey(kv.key())) + .map(KeyValuePair::value) + .filter(ListLiteral.class::isInstance) + .map(ListLiteral.class::cast) + .map(ListLiteral::elements) + .map(ExpressionList::expressions) + .flatMap(List::stream) + .anyMatch(expr -> expr == usageTree); + } + + private static boolean isRequestOrResponseKey(Expression key) { + return key instanceof StringLiteral stringLiteral && + ("request".equals(stringLiteral.trimmedQuotesValue()) || "response".equals(stringLiteral.trimmedQuotesValue())); + } + + private static boolean isAioConsumerSubscribeCallback(Tree usageTree, SubscriptionContext ctx) { + RegularArgument arg = TreeUtils.firstAncestorOfClass(usageTree, RegularArgument.class); + if (arg == null || arg.expression() != usageTree) { + return false; + } + Name keyword = arg.keywordArgument(); + if (keyword == null || !AIO_CONSUMER_SUBSCRIBE_CALLBACK_KWARGS.contains(keyword.name())) { + return false; + } + CallExpression call = TreeUtils.firstAncestorOfClass(arg, CallExpression.class); + return call != null && AIO_CONSUMER_SUBSCRIBE_MATCHER.isTrueFor(call.callee(), ctx); } private static boolean isDunderMethod(FunctionDef functionDef) { @@ -84,18 +152,18 @@ private static boolean isDunderMethod(FunctionDef functionDef) { return methodName.startsWith("__"); } - private boolean isTrivialFunction(StatementList body) { + private static boolean isTrivialFunction(StatementList body, SubscriptionContext ctx) { for (Statement statement : body.statements()) { - if (!CheckUtils.isEmptyStatement(statement) && !statement.is(Tree.Kind.RAISE_STMT) && !isReturnNotImplemented(statement)) { + if (!CheckUtils.isEmptyStatement(statement) && !statement.is(Tree.Kind.RAISE_STMT) && !isReturnNotImplemented(statement, ctx)) { return false; } } return true; } - private boolean isReturnNotImplemented(Statement statement) { + private static boolean isReturnNotImplemented(Statement statement, SubscriptionContext ctx) { return statement.is(Tree.Kind.RETURN_STMT) && - ((ReturnStatement) statement).expressions().stream().allMatch(e -> notImplementedTypeChecker.check(e.typeV2()) == TriBool.TRUE); + ((ReturnStatement) statement).expressions().stream().allMatch(e -> NOT_IMPLEMENTED_MATCHER.isTrueFor(e, ctx)); } private static boolean mightBeOverridingMethod(FunctionDef functionDef) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/AsyncFunctionWithTimeoutCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AsyncFunctionWithTimeoutCheck.java index 9f5fb83ff8..4375acfcb4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AsyncFunctionWithTimeoutCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AsyncFunctionWithTimeoutCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AsyncLongSleepCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AsyncLongSleepCheck.java index b945bb01c8..def3df16b5 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AsyncLongSleepCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AsyncLongSleepCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AsyncWithContextManagerCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AsyncWithContextManagerCheck.java index 6aa5996f11..5eb05ca264 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AsyncWithContextManagerCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AsyncWithContextManagerCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AsyncioTaskNotStoredCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AsyncioTaskNotStoredCheck.java index 9085ae5c23..515eac81cb 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AsyncioTaskNotStoredCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AsyncioTaskNotStoredCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsClientExceptionNotCaughtCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsClientExceptionNotCaughtCheck.java index 8a02247923..2747f63ef8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsClientExceptionNotCaughtCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsClientExceptionNotCaughtCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsCustomMetricNamespaceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsCustomMetricNamespaceCheck.java index ca0dfd1818..3db87d5eed 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsCustomMetricNamespaceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsCustomMetricNamespaceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsExpectedBucketOwnerCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsExpectedBucketOwnerCheck.java index 88dbafbddf..65d22d62c7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsExpectedBucketOwnerCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsExpectedBucketOwnerCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsHardcodedRegionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsHardcodedRegionCheck.java index a9c55839fc..57cfc5ee58 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsHardcodedRegionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsHardcodedRegionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaClientInstantiationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaClientInstantiationCheck.java index 06713fddb5..ac8777dd54 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaClientInstantiationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaClientInstantiationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaCrossCallCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaCrossCallCheck.java index 34ea0b1943..29c5024519 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaCrossCallCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaCrossCallCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaReservedEnvironmentVariableCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaReservedEnvironmentVariableCheck.java index 27e87e25c2..8b93de8551 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaReservedEnvironmentVariableCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaReservedEnvironmentVariableCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaReturnValueAreSerializableCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaReturnValueAreSerializableCheck.java index b0674fe921..dfb4c1c80d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaReturnValueAreSerializableCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaReturnValueAreSerializableCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaTmpCleanupCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaTmpCleanupCheck.java index 2fa10a1245..730a4233ce 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaTmpCleanupCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsLambdaTmpCleanupCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsLongTermAccessKeysCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsLongTermAccessKeysCheck.java index 00d7889e3f..cffe7e0bac 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsLongTermAccessKeysCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsLongTermAccessKeysCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsMissingPaginationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsMissingPaginationCheck.java index ee24801c66..482538eba6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsMissingPaginationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsMissingPaginationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/AwsWaitersInsteadOfCustomPollingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/AwsWaitersInsteadOfCustomPollingCheck.java index a704f8c30f..8330066cab 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/AwsWaitersInsteadOfCustomPollingCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/AwsWaitersInsteadOfCustomPollingCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/BackslashInStringCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BackslashInStringCheck.java index 63c5fc6077..f0dd403303 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BackslashInStringCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BackslashInStringCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/BackticksUsageCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BackticksUsageCheck.java index 39389e7940..88d8b7125a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BackticksUsageCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BackticksUsageCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/BareRaiseInFinallyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BareRaiseInFinallyCheck.java index 8ffcc2ceaf..6ab547a02d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BareRaiseInFinallyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BareRaiseInFinallyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupClassListCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupClassListCheck.java new file mode 100644 index 0000000000..970b3bf6d0 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupClassListCheck.java @@ -0,0 +1,145 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.Optional; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ListLiteral; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8906") +public class BeautifulSoupClassListCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE_TEMPLATE = "Use \"%s()\" with a chained CSS class selector instead."; + private static final String MESSAGE_SELECT_ONE = MESSAGE_TEMPLATE.formatted("select_one"); + private static final String MESSAGE_SELECT = MESSAGE_TEMPLATE.formatted("select"); + + + private static final TypeMatcher IS_BS4_PAGE_ELEMENT_INSTANCE = TypeMatchers.isObjectInstanceOf("bs4.element.PageElement"); + + private static TypeMatcher bs4Matcher(String suffix) { + return TypeMatchers.isType("bs4.element." + suffix); + } + + // Single-result methods: the correct CSS replacement is select_one(). + // Defined on Tag: find. Defined on PageElement: find_parent, find_next, find_next_sibling, find_previous, find_previous_sibling. + private static final TypeMatcher IS_BS4_SINGLE_RESULT_CALL = TypeMatchers.any( + bs4Matcher("Tag.find"), + bs4Matcher("PageElement.find_parent"), + bs4Matcher("PageElement.find_next"), + bs4Matcher("PageElement.find_next_sibling"), + bs4Matcher("PageElement.find_previous"), + bs4Matcher("PageElement.find_previous_sibling") + ); + + // List-returning methods: the correct CSS replacement is select(). + // Defined on Tag: find_all. Defined on PageElement: find_parents, find_all_next, find_next_siblings, find_all_previous, find_previous_siblings. + private static final TypeMatcher IS_BS4_LIST_RESULT_CALL = TypeMatchers.any( + bs4Matcher("Tag.find_all"), + bs4Matcher("PageElement.find_parents"), + bs4Matcher("PageElement.find_all_next"), + bs4Matcher("PageElement.find_next_siblings"), + bs4Matcher("PageElement.find_all_previous"), + bs4Matcher("PageElement.find_previous_siblings") + ); + + // Deprecated camelCase aliases; type inference cannot resolve them (they are simple assignments in the stubs). + // Instead we check: method name is in this set AND qualifier is a bs4.element.Tag instance. + // BeautifulSoup extends Tag, so isObjectInstanceOf("bs4.element.Tag") covers both. + private static final Set DEPRECATED_SINGLE_RESULT_NAMES = Set.of( + "findChild", + "findParent", + "findNext", + "findNextSibling", + "findPrevious", + "findPreviousSibling" + ); + + private static final Set DEPRECATED_LIST_RESULT_NAMES = Set.of( + "findAll", + "findChildren", + "findParents", + "findAllNext", + "findNextSiblings", + "findAllPrevious", + "findPreviousSiblings" + ); + + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, BeautifulSoupClassListCheck::checkCallExpression); + } + + private static void checkCallExpression(SubscriptionContext ctx) { + CallExpression call = (CallExpression) ctx.syntaxNode(); + RegularArgument classArg = TreeUtils.argumentByKeyword("class_", call.arguments()); + if (classArg == null || !classArg.expression().is(Tree.Kind.LIST_LITERAL)) { + return; + } + ListLiteral listLiteral = (ListLiteral) classArg.expression(); + if (listLiteral.elements().expressions().size() < 2) { + return; + } + messageForCall(call, ctx).ifPresent(message -> ctx.addIssue(classArg, message)); + } + + /** + * Returns the appropriate issue message if the call targets a bs4 search method, or empty otherwise. + * Single-result methods (find, find_parent, …) → MESSAGE_SELECT_ONE. + * List-returning methods (find_all, find_parents, …) → MESSAGE_SELECT. + */ + private static Optional messageForCall(CallExpression call, SubscriptionContext ctx) { + Expression callee = call.callee(); + // Path 1: modern snake_case methods — resolved via type inference + if (IS_BS4_SINGLE_RESULT_CALL.isTrueFor(callee, ctx)) { + return Optional.of(MESSAGE_SELECT_ONE); + } + if (IS_BS4_LIST_RESULT_CALL.isTrueFor(callee, ctx)) { + return Optional.of(MESSAGE_SELECT); + } + // Path 2: deprecated camelCase aliases — detected by method name + qualifier type + if (callee instanceof QualifiedExpression qualifiedExpression) { + return messageForDeprecatedAlias(qualifiedExpression, ctx); + } + return Optional.empty(); + } + + private static Optional messageForDeprecatedAlias(QualifiedExpression qualifiedExpression, SubscriptionContext ctx) { + String name = qualifiedExpression.name().name(); + if (!IS_BS4_PAGE_ELEMENT_INSTANCE.isTrueFor(qualifiedExpression.qualifier(), ctx)) { + return Optional.empty(); + } + if (DEPRECATED_SINGLE_RESULT_NAMES.contains(name)) { + return Optional.of(MESSAGE_SELECT_ONE); + } + if (DEPRECATED_LIST_RESULT_NAMES.contains(name)) { + return Optional.of(MESSAGE_SELECT); + } + return Optional.empty(); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupDeprecatedNamesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupDeprecatedNamesCheck.java new file mode 100644 index 0000000000..e88a099ba5 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupDeprecatedNamesCheck.java @@ -0,0 +1,186 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8900") +public class BeautifulSoupDeprecatedNamesCheck extends PythonSubscriptionCheck { + + // All deprecated methods and attributes are defined on PageElement (the base class), + // so using isObjectInstanceOf covers BeautifulSoup, Tag, and their subclasses. + private static final TypeMatcher BS4_MATCHER = TypeMatchers.isObjectInstanceOf("bs4.element.PageElement"); + + // Maps deprecated method names to their modern equivalents + private static final Map DEPRECATED_METHODS; + static { + Map m = new LinkedHashMap<>(); + m.put("findAll", "find_all"); + m.put("findChild", "find"); + m.put("findChildren", "find_all"); + m.put("findNext", "find_next"); + m.put("findAllNext", "find_all_next"); + m.put("findPrevious", "find_previous"); + m.put("findAllPrevious", "find_all_previous"); + m.put("findNextSibling", "find_next_sibling"); + m.put("findNextSiblings", "find_next_siblings"); + m.put("findPreviousSibling", "find_previous_sibling"); + m.put("findPreviousSiblings", "find_previous_siblings"); + m.put("findParent", "find_parent"); + m.put("findParents", "find_parents"); + m.put("replaceWith", "replace_with"); + m.put("getText", "get_text"); + DEPRECATED_METHODS = Collections.unmodifiableMap(m); + } + + // Maps deprecated attribute names to their modern equivalents + private static final Map DEPRECATED_ATTRS; + static { + Map m = new LinkedHashMap<>(); + m.put("nextSibling", "next_sibling"); + m.put("previousSibling", "previous_sibling"); + DEPRECATED_ATTRS = Collections.unmodifiableMap(m); + } + + // Modern find-family method names that accept the text= keyword argument. + // replaceWith/replace_with and getText/get_text are intentionally excluded. + private static final Set FIND_FAMILY_MODERN_METHODS; + static { + Set s = new LinkedHashSet<>(); + s.add("find"); + s.add("find_all"); + s.add("find_next"); + s.add("find_all_next"); + s.add("find_previous"); + s.add("find_all_previous"); + s.add("find_next_sibling"); + s.add("find_next_siblings"); + s.add("find_previous_sibling"); + s.add("find_previous_siblings"); + FIND_FAMILY_MODERN_METHODS = Collections.unmodifiableSet(s); + } + + // Union of modern find-family names and all deprecated names that map to one of them. + // Derived to avoid duplicating the deprecated keys from DEPRECATED_METHODS. + private static final Set FIND_FAMILY_METHODS; + static { + LinkedHashSet s = Stream.concat( + FIND_FAMILY_MODERN_METHODS.stream(), + DEPRECATED_METHODS.entrySet().stream() + .filter(e -> FIND_FAMILY_MODERN_METHODS.contains(e.getValue())) + .map(Map.Entry::getKey) + ).collect(Collectors.toCollection(LinkedHashSet::new)); + FIND_FAMILY_METHODS = Collections.unmodifiableSet(s); + } + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, BeautifulSoupDeprecatedNamesCheck::checkCallExpression); + context.registerSyntaxNodeConsumer(Tree.Kind.QUALIFIED_EXPR, BeautifulSoupDeprecatedNamesCheck::checkQualifiedExpression); + } + + private static void checkCallExpression(SubscriptionContext ctx) { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + + if (!(callExpression.callee() instanceof QualifiedExpression qualifiedExpr)) { + return; + } + + String methodName = qualifiedExpr.name().name(); + Expression receiver = qualifiedExpr.qualifier(); + + if (!BS4_MATCHER.isTrueFor(receiver, ctx)) { + return; + } + + // Check for deprecated method name + // We need to use the name as findAll FQN resolves to find_all + String modernMethod = DEPRECATED_METHODS.get(methodName); + if (modernMethod != null) { + PreciseIssue issue = ctx.addIssue(qualifiedExpr.name(), + String.format("Replace the deprecated '%s()' method with '%s()'.", methodName, modernMethod)); + issue.addQuickFix(PythonQuickFix.newQuickFix( + "Replace '%s()' with '%s()'".formatted(methodName, modernMethod), + TextEditUtils.replace(qualifiedExpr.name(), modernMethod) + )); + } + + // Check for deprecated text= keyword argument (in any find-family method) + if (FIND_FAMILY_METHODS.contains(methodName)) { + checkDeprecatedTextKeyword(ctx, callExpression.arguments()); + } + } + + private static void checkDeprecatedTextKeyword(SubscriptionContext ctx, List arguments) { + RegularArgument textArg = TreeUtils.argumentByKeyword("text", arguments); + if (textArg != null && textArg.keywordArgument() != null) { + PreciseIssue issue = ctx.addIssue(textArg.keywordArgument(), + "Replace the deprecated 'text' keyword argument with 'string'."); + issue.addQuickFix(PythonQuickFix.newQuickFix( + "Replace 'text' with 'string'", + TextEditUtils.replace(textArg.keywordArgument(), "string") + )); + } + } + + private static void checkQualifiedExpression(SubscriptionContext ctx) { + QualifiedExpression qualifiedExpr = (QualifiedExpression) ctx.syntaxNode(); + + // Skip if this is the callee of a call expression — that case is handled by checkCallExpression + if (qualifiedExpr.parent() instanceof CallExpression parentCall + && parentCall.callee() == qualifiedExpr) { + return; + } + + String attrName = qualifiedExpr.name().name(); + String modernAttr = DEPRECATED_ATTRS.get(attrName); + if (modernAttr == null) { + return; + } + + Expression qualifier = qualifiedExpr.qualifier(); + if (BS4_MATCHER.isTrueFor(qualifier, ctx)) { + PreciseIssue issue = ctx.addIssue(qualifiedExpr.name(), + String.format("Replace the deprecated '%s' attribute with '%s'.", attrName, modernAttr)); + issue.addQuickFix(PythonQuickFix.newQuickFix( + "Replace '%s' with '%s'".formatted(attrName, modernAttr), + TextEditUtils.replace(qualifiedExpr.name(), modernAttr) + )); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupNoneCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupNoneCheck.java new file mode 100644 index 0000000000..8467084618 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupNoneCheck.java @@ -0,0 +1,305 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.List; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.tree.AssertStatement; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.ExceptClause; +import org.sonar.plugins.python.api.tree.TryStatement; +import org.sonar.plugins.python.api.tree.BinaryExpression; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.IfStatement; +import org.sonar.plugins.python.api.tree.IsExpression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.SubscriptionExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.UnaryExpression; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8904") +public class BeautifulSoupNoneCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Check if this element exists before accessing it with `%s`."; + + private static TypeMatcher bs4Matcher(String suffix) { + return TypeMatchers.isType("bs4.element." + suffix); + } + + // Covers find/select_one (defined on Tag) and the find_* / find_parent methods (defined on PageElement) + private static final TypeMatcher IS_BS4_SEARCH_CALL = TypeMatchers.any( + bs4Matcher("Tag.find"), + bs4Matcher("Tag.select_one"), + bs4Matcher("PageElement.find_next"), + bs4Matcher("PageElement.find_previous"), + bs4Matcher("PageElement.find_next_sibling"), + bs4Matcher("PageElement.find_previous_sibling"), + bs4Matcher("PageElement.find_parent")); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.QUALIFIED_EXPR, BeautifulSoupNoneCheck::checkQualifiedExpr); + context.registerSyntaxNodeConsumer(Tree.Kind.SUBSCRIPTION, BeautifulSoupNoneCheck::checkSubscription); + } + + private static void checkQualifiedExpr(SubscriptionContext ctx) { + QualifiedExpression qe = (QualifiedExpression) ctx.syntaxNode(); + // When a QualifiedExpression is the callee of a BS4 search call (e.g. "soup.find"), + // skip it — unless its qualifier is itself a BS4 search call result (e.g. "soup.find("div").find"). + // The former is safe (soup is not None); the latter is unsafe (soup.find("div") may be None). + if (qe.parent() instanceof CallExpression callParent + && callParent.callee() == qe + && IS_BS4_SEARCH_CALL.isTrueFor(qe, ctx) + && !(qe.qualifier() instanceof CallExpression qualifierCall && isBS4SearchCall(qualifierCall, ctx))) { + return; + } + checkObjectAccess(qe.qualifier(), qe.name(), "." + qe.name().name(), ctx); + } + + private static void checkSubscription(SubscriptionContext ctx) { + SubscriptionExpression se = (SubscriptionExpression) ctx.syntaxNode(); + if (isAssignmentTarget(se)) { + return; + } + checkObjectAccess(se.object(), se, subscriptDescription(se), ctx); + } + + private static String subscriptDescription(SubscriptionExpression se) { + var subscripts = se.subscripts().expressions(); + if (subscripts.size() == 1 && subscripts.get(0) instanceof StringLiteral str) { + return String.format("[%s]", str.trimmedQuotesValue()); + } + return "[]"; + } + + private static void checkObjectAccess(Expression object, Tree issueLocation, String accessDescription, SubscriptionContext ctx) { + if (isInsideCatchingTry(issueLocation, ctx)) { + return; + } + // Case 1: direct inline chaining — the object is itself a BS4 search call. + // Only raise on the first unsafe access in a chain: skip if the object's own qualifier is + // already a BS4 search call (meaning an earlier issue was already raised for that access). + // e.g. soup.find("div").find("p").text — raise on the first find, not the second + if (object instanceof CallExpression callExpr && isBS4SearchCall(callExpr, ctx)) { + if (callExpr.callee() instanceof QualifiedExpression innerQe + && innerQe.qualifier() instanceof CallExpression innerQualifierCall + && isBS4SearchCall(innerQualifierCall, ctx)) { + return; + } + // Highlight the name of the call that produced the potentially-None object + // e.g. for soup.find("p").text → highlight "find"; for soup.find("div").find("p") → highlight the first "find" + Tree calleeNameLocation = callExpr.callee() instanceof QualifiedExpression calleeQe + ? calleeQe.name() + : issueLocation; + ctx.addIssue(calleeNameLocation, MESSAGE.formatted(accessDescription)); + return; + } + // Case 2: variable whose value at this location comes from a BS4 search call + if (object instanceof Name name) { + checkNameAccess(name, issueLocation, accessDescription, ctx); + } + } + + private static boolean isInsideCatchingTry(Tree tree, SubscriptionContext ctx) { + TryStatement enclosingTry = (TryStatement) TreeUtils.firstAncestorOfKind(tree, Tree.Kind.TRY_STMT); + return enclosingTry != null + && TreeUtils.hasDescendant(enclosingTry.body(), t -> t == tree) + && catchesAttributeError(enclosingTry.exceptClauses(), ctx); + } + + private static void checkNameAccess(Name name, Tree issueLocation, String accessDescription, SubscriptionContext ctx) { + Set values = ctx.valuesAtLocation(name); + if (values.isEmpty()) { + return; + } + boolean allBS4Calls = values.stream() + .allMatch(v -> v instanceof CallExpression callExpr && isBS4SearchCall(callExpr, ctx)); + if (!allBS4Calls) { + return; + } + if (isGuardedByNoneCheck(name)) { + return; + } + ctx.addIssue(issueLocation, MESSAGE.formatted(accessDescription)); + } + + private static boolean isBS4SearchCall(CallExpression callExpr, SubscriptionContext ctx) { + return IS_BS4_SEARCH_CALL.isTrueFor(callExpr.callee(), ctx); + } + + /** + * Returns true if the Name is guarded against None. Recognises three patterns: + * 1. Enclosing if-body guard: walks *all* enclosing IfStatements (not just the nearest) so that + * nested ifs inside a guard are covered. Conditions may include "and"-chains. + * e.g. "if name:", "if name is not None:", "if name != None:", "if name is not None and other:" + * 2. Early-exit guard: a preceding usage of the same symbol appears as the subject of an + * IfStatement that exits unconditionally (return/raise/continue/break) when the name is + * None or falsy: "if name is None: return" / "if not name: return" + * 3. Assert guard: a preceding assert statement whose condition matches conditionChecksForTruthy: + * "assert name" / "assert name is not None" + */ + private static boolean isGuardedByNoneCheck(Name name) { + // Pattern 1: walk all enclosing IfStatements, not just the nearest + Tree cursor = name.parent(); + while (cursor != null) { + if (cursor instanceof IfStatement ifStmt + && TreeUtils.hasDescendant(ifStmt.body(), t -> t == name) + && conditionChecksForTruthy(ifStmt.condition(), name)) { + return true; + } + cursor = cursor.parent(); + } + + SymbolV2 symbol = name.symbolV2(); + if (symbol == null) { + return false; + } + int nameLine = name.firstToken().line(); + + // Pattern 2: an earlier usage of the same symbol is guarded by an early-exit if-statement + if (symbol.usages().stream() + .filter(u -> u.tree().firstToken().line() < nameLine) + .map(u -> TreeUtils.firstAncestorOfKind(u.tree(), Tree.Kind.IF_STMT)) + .filter(IfStatement.class::isInstance) + .map(IfStatement.class::cast) + .anyMatch(ifStmt -> isEarlyExitNoneGuard(ifStmt, name))) { + return true; + } + + // Pattern 3: assert statement whose condition guards the name + return symbol.usages().stream() + .filter(u -> u.tree().firstToken().line() < nameLine) + .map(u -> TreeUtils.firstAncestorOfKind(u.tree(), Tree.Kind.ASSERT_STMT)) + .filter(AssertStatement.class::isInstance) + .map(AssertStatement.class::cast) + .anyMatch(assertStmt -> conditionChecksForTruthy(assertStmt.condition(), name)); + } + + private static final TypeMatcher IS_ATTRIBUTE_ERROR = + TypeMatchers.isOrExtendsType("builtins.AttributeError"); + + private static boolean catchesAttributeError(List exceptClauses, SubscriptionContext ctx) { + for (ExceptClause clause : exceptClauses) { + Expression exception = clause.exception(); + if (exception == null) { + // bare "except:" — too broad, do not suppress + return false; + } + // check each exception type in the clause (handles "except (AttributeError, TypeError):") + List caught = TreeUtils.flattenTuples(exception).toList(); + for (Expression expr : caught) { + if (IS_ATTRIBUTE_ERROR.isTrueFor(expr, ctx)) { + return true; + } + } + } + return false; + } + + /** + * Returns true if the if-statement exits unconditionally (return/raise/continue/break) and + * its condition tests the name for None or falsiness. + * Recognised conditions: "name is None", "not name", "name == None" + */ + private static boolean isEarlyExitNoneGuard(IfStatement ifStmt, Name name) { + var stmts = ifStmt.body().statements(); + if (stmts.isEmpty()) { + return false; + } + if (!stmts.get(stmts.size() - 1).is(Tree.Kind.RETURN_STMT, Tree.Kind.RAISE_STMT, Tree.Kind.CONTINUE_STMT, Tree.Kind.BREAK_STMT)) { + return false; + } + return conditionChecksForNoneOrFalsy(ifStmt.condition(), name); + } + + /** + * Checks if the condition tests the name for None or falsiness (the inverse of a positive guard). + * Recognised: "not name", "name is None", "name == None" + */ + private static boolean conditionChecksForNoneOrFalsy(Expression condition, Name name) { + // "if not element:" + if (condition instanceof UnaryExpression unary + && "not".equals(unary.operator().value()) + && nameMatchesExpressionName(name, unary.expression())) { + return true; + } + // "if element is None:" / "if None is element:" + if (condition instanceof IsExpression isExpr && isExpr.notToken() == null) { + return nameComparedToNone(name, isExpr.leftOperand(), isExpr.rightOperand()); + } + // "if element == None:" / "if None == element:" + if (condition instanceof BinaryExpression binaryExpr + && condition.is(Tree.Kind.COMPARISON) + && "==".equals(binaryExpr.operator().value())) { + return nameComparedToNone(name, binaryExpr.leftOperand(), binaryExpr.rightOperand()); + } + return false; + } + + private static boolean conditionChecksForTruthy(Expression condition, Name name) { + // "if element:" + if (nameMatchesExpressionName(name, condition)) { + return true; + } + // "if and other:" / "if other and :" — recurse into both operands of "and" + if (condition instanceof BinaryExpression andExpr + && condition.is(Tree.Kind.AND) + && (conditionChecksForTruthy(andExpr.leftOperand(), name) + || conditionChecksForTruthy(andExpr.rightOperand(), name))) { + return true; + } + // "if element is not None:" / "if None is not element:" + if (condition instanceof IsExpression isExpr && isExpr.notToken() != null) { + return nameComparedToNone(name, isExpr.leftOperand(), isExpr.rightOperand()); + } + // "if element != None:" / "if None != element:" + if (condition instanceof BinaryExpression binaryExpr + && condition.is(Tree.Kind.COMPARISON) + && "!=".equals(binaryExpr.operator().value())) { + return nameComparedToNone(name, binaryExpr.leftOperand(), binaryExpr.rightOperand()); + } + return false; + } + + /** Returns true if one operand is the name and the other is None (in either order). */ + private static boolean nameComparedToNone(Name name, Expression left, Expression right) { + return (nameMatchesExpressionName(name, left) && right.is(Tree.Kind.NONE)) + || (nameMatchesExpressionName(name, right) && left.is(Tree.Kind.NONE)); + } + + private static boolean nameMatchesExpressionName(Name name, Expression operand) { + return operand instanceof Name opName && opName.name().equals(name.name()); + } + + private static boolean isAssignmentTarget(SubscriptionExpression subscriptionExpression) { + return TreeUtils.firstAncestor(subscriptionExpression, + t -> t.is(Tree.Kind.ASSIGNMENT_STMT) + && ((AssignmentStatement) t).lhsExpressions().stream() + .flatMap(lhs -> lhs.expressions().stream()) + .anyMatch(expr -> expr.equals(subscriptionExpression))) != null; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupParserCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupParserCheck.java new file mode 100644 index 0000000000..ccd733ecd6 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupParserCheck.java @@ -0,0 +1,57 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8905") +public class BeautifulSoupParserCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Specify the parser to use for \"BeautifulSoup\"."; + private static final TypeMatcher BEAUTIFUL_SOUP_MATCHER = TypeMatchers.isType("bs4.BeautifulSoup"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, BeautifulSoupParserCheck::checkCallExpression); + } + + private static void checkCallExpression(SubscriptionContext ctx) { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + + if (!BEAUTIFUL_SOUP_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return; + } + + List arguments = callExpression.arguments(); + + var features = TreeUtils.nthArgumentOrKeyword(1, "features", arguments); + var builder = TreeUtils.nthArgumentOrKeyword(2, "builder", arguments); + + if (features == null && builder == null) { + ctx.addIssue(callExpression.callee(), MESSAGE); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupRawHtmlInsertionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupRawHtmlInsertionCheck.java new file mode 100644 index 0000000000..7166b0d562 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/BeautifulSoupRawHtmlInsertionCheck.java @@ -0,0 +1,75 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.Map; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8903") +public class BeautifulSoupRawHtmlInsertionCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Use \"new_tag()\" instead of inserting raw HTML strings."; + + private record MethodSpec(int argIndex, String keyword) {} + + private static final Map INSERTION_METHODS = Map.of( + TypeMatchers.isType("bs4.element.PageElement.insert"), new MethodSpec(1, "new_child"), + TypeMatchers.isType("bs4.element.PageElement.append"), new MethodSpec(0, "tag"), + TypeMatchers.isType("bs4.element.PageElement.extend"), new MethodSpec(0, "tags") + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, BeautifulSoupRawHtmlInsertionCheck::checkCallExpression); + } + + private static boolean looksLikeHtmlMarkup(Expression expr) { + StringLiteral literal = Expressions.extractStringLiteral(expr); + return literal != null && + literal.trimmedQuotesValue().startsWith("<") && + literal.trimmedQuotesValue().endsWith(">"); + } + + private static void checkCallExpression(SubscriptionContext ctx) { + CallExpression callExpr = (CallExpression) ctx.syntaxNode(); + + if (!(callExpr.callee() instanceof QualifiedExpression qualifiedExpr)) { + return; + } + + INSERTION_METHODS.entrySet().stream() + .filter(e -> e.getKey().isTrueFor(qualifiedExpr, ctx)) + .map(Map.Entry::getValue) + .findFirst() + .flatMap(spec -> TreeUtils.nthArgumentOrKeywordOptional(spec.argIndex(), spec.keyword(), callExpr.arguments())) + .map(RegularArgument::expression) + .filter(BeautifulSoupRawHtmlInsertionCheck::looksLikeHtmlMarkup) + .ifPresent(contentExpr -> ctx.addIssue(qualifiedExpr.name(), MESSAGE)); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/BindToAllNetworkInterfacesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BindToAllNetworkInterfacesCheck.java index 542c6856aa..bdc5f1e101 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BindToAllNetworkInterfacesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BindToAllNetworkInterfacesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/BooleanCheckNotInvertedCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BooleanCheckNotInvertedCheck.java index 84b4a714d9..b25ed8b2e3 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BooleanCheckNotInvertedCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BooleanCheckNotInvertedCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -157,6 +157,7 @@ private static boolean isSetComparison(BinaryExpression binaryExpression) { binaryExpression.leftOperand().type(), binaryExpression.rightOperand().type() ); - return inferredTypeSet.stream().anyMatch(inferredType -> inferredType.mustBeOrExtend(BuiltinTypes.SET)); + return inferredTypeSet.stream().anyMatch(inferredType -> + inferredType.mustBeOrExtend(BuiltinTypes.SET) || inferredType.mustBeOrExtend(BuiltinTypes.FROZENSET)); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/BooleanExpressionInExceptCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BooleanExpressionInExceptCheck.java index ec195c4765..6c37c06785 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BooleanExpressionInExceptCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BooleanExpressionInExceptCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -41,6 +41,10 @@ public class BooleanExpressionInExceptCheck extends PythonSubscriptionCheck { public static final String MESSAGE = "Rewrite this \"except\" expression as a tuple of exception classes."; public static final String QUICK_FIX_MESSAGE = "Replace with a tuple"; + private static final Kind[] FLAGGED_BINARY_KINDS = { + Kind.OR, Kind.AND, Kind.BITWISE_OR, Kind.BITWISE_AND + }; + @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Kind.EXCEPT_CLAUSE, BooleanExpressionInExceptCheck::checkExceptClause); @@ -52,7 +56,7 @@ private static void checkExceptClause(SubscriptionContext ctx) { Optional.of(except) .map(ExceptClause::exception) .map(Expressions::removeParentheses) - .filter(exception -> exception.is(Kind.OR, Kind.AND)) + .filter(exception -> exception.is(FLAGGED_BINARY_KINDS)) .ifPresent(exception -> { var issue = ctx.addIssue(exception, MESSAGE); addQuickFix(issue, exception); @@ -61,7 +65,7 @@ private static void checkExceptClause(SubscriptionContext ctx) { private static List collectNames(Expression expression) { expression = Expressions.removeParentheses(expression); - if (expression.is(Kind.OR, Kind.AND)) { + if (expression.is(FLAGGED_BINARY_KINDS)) { var binaryExpression = (BinaryExpression) expression; var leftExceptions = collectNames(binaryExpression.leftOperand()); var rightExceptions = collectNames(binaryExpression.rightOperand()); diff --git a/python-checks/src/main/java/org/sonar/python/checks/BreakContinueOutsideLoopCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BreakContinueOutsideLoopCheck.java index 8f8a6d4e82..d3ec578e55 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BreakContinueOutsideLoopCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BreakContinueOutsideLoopCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/BuiltinGenericsOverTypingModuleCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BuiltinGenericsOverTypingModuleCheck.java index 8fa6cca16f..75bb50b158 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BuiltinGenericsOverTypingModuleCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BuiltinGenericsOverTypingModuleCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/BuiltinShadowingAssignmentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BuiltinShadowingAssignmentCheck.java index b9df7c8685..f5e0980749 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BuiltinShadowingAssignmentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BuiltinShadowingAssignmentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/BusyWaitingInAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/BusyWaitingInAsyncCheck.java index 0cb5a143c3..c42ef13c17 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/BusyWaitingInAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/BusyWaitingInAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CancellationReraisedInAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CancellationReraisedInAsyncCheck.java index 9ada400d9a..2c3c77c04a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CancellationReraisedInAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CancellationReraisedInAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CancellationScopeNoCheckpointCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CancellationScopeNoCheckpointCheck.java index ffec6922a9..3d457ee37b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CancellationScopeNoCheckpointCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CancellationScopeNoCheckpointCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CaughtExceptionsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CaughtExceptionsCheck.java index 2de88606a0..e63cc68f0a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CaughtExceptionsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CaughtExceptionsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ChangeMethodContractCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ChangeMethodContractCheck.java index c660005b81..71cd98c13d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ChangeMethodContractCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ChangeMethodContractCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ChildAndParentExceptionCaughtCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ChildAndParentExceptionCaughtCheck.java index 98b3b62978..afd2d432af 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ChildAndParentExceptionCaughtCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ChildAndParentExceptionCaughtCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ChildRouterBeforeParentRegistrationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ChildRouterBeforeParentRegistrationCheck.java index ccbad390ad..d6c236e041 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ChildRouterBeforeParentRegistrationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ChildRouterBeforeParentRegistrationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CipherBlockChainingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CipherBlockChainingCheck.java index 97d1184cf4..d038fe96bb 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CipherBlockChainingCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CipherBlockChainingCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ClassComplexityCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ClassComplexityCheck.java index 99ab78a151..433ec6219c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ClassComplexityCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ClassComplexityCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ClassFieldDefinedMultipleTimesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ClassFieldDefinedMultipleTimesCheck.java new file mode 100644 index 0000000000..eab3dff8b5 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/ClassFieldDefinedMultipleTimesCheck.java @@ -0,0 +1,94 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.Tree.Kind; + +@Rule(key = "S8512") +public class ClassFieldDefinedMultipleTimesCheck extends PythonSubscriptionCheck { + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Kind.CLASSDEF, ctx -> checkClass(ctx, (ClassDef) ctx.syntaxNode())); + } + + private static void checkClass(SubscriptionContext ctx, ClassDef classDef) { + Map> fieldDefinitions = new LinkedHashMap<>(); + + for (Statement stmt : classDef.body().statements()) { + collectFieldDefinition(stmt, fieldDefinitions); + } + + reportDuplicateDefinitions(ctx, fieldDefinitions); + } + + private static void collectFieldDefinition(Statement stmt, Map> fieldDefinitions) { + if (stmt.is(Kind.ASSIGNMENT_STMT)) { + getAssignmentName((AssignmentStatement) stmt) + .ifPresent(name -> fieldDefinitions.computeIfAbsent(name.name(), k -> new ArrayList<>()).add(name)); + } else if (stmt.is(Kind.ANNOTATED_ASSIGNMENT)) { + getAnnotatedAssignmentName((AnnotatedAssignment) stmt) + .ifPresent(name -> fieldDefinitions.computeIfAbsent(name.name(), k -> new ArrayList<>()).add(name)); + } + } + + private static Optional getAssignmentName(AssignmentStatement assignment) { + List lhsList = assignment.lhsExpressions(); + if (lhsList.size() != 1) { + return Optional.empty(); + } + List expressions = lhsList.get(0).expressions(); + if (expressions.size() == 1 && expressions.get(0).is(Kind.NAME)) { + return Optional.of((Name) expressions.get(0)); + } + return Optional.empty(); + } + + private static Optional getAnnotatedAssignmentName(AnnotatedAssignment annotated) { + if (annotated.variable().is(Kind.NAME) && annotated.assignedValue() != null) { + return Optional.of((Name) annotated.variable()); + } + return Optional.empty(); + } + + private static void reportDuplicateDefinitions(SubscriptionContext ctx, Map> fieldDefinitions) { + fieldDefinitions.forEach((name, definitions) -> { + for (int i = 0; i < definitions.size() - 1; i++) { + Tree current = definitions.get(i); + Tree next = definitions.get(i + 1); + String message = String.format("Remove this assignment; \"%s\" is assigned again on line %d.", name, next.firstToken().line()); + ctx.addIssue(current, message).secondary(next, "Reassignment."); + } + }); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/ClassMethodFirstArgumentNameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ClassMethodFirstArgumentNameCheck.java index 4cd3ab25bc..cd6f86fdad 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ClassMethodFirstArgumentNameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ClassMethodFirstArgumentNameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ClassNameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ClassNameCheck.java index 377c1c83b1..19910cc06b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ClassNameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ClassNameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CognitiveComplexityFunctionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CognitiveComplexityFunctionCheck.java index 7a431c2be7..4eab6d6101 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CognitiveComplexityFunctionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CognitiveComplexityFunctionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -22,8 +22,10 @@ import org.sonar.check.RuleProperty; import org.sonar.plugins.python.api.IssueLocation; import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.tree.FunctionDef; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.python.checks.utils.GeneratedFileUtils; import org.sonar.python.metrics.CognitiveComplexityVisitor; @Rule(key = CognitiveComplexityFunctionCheck.CHECK_KEY) @@ -33,6 +35,8 @@ public class CognitiveComplexityFunctionCheck extends PythonSubscriptionCheck { public static final String CHECK_KEY = "S3776"; private static final int DEFAULT_THRESHOLD = 15; + private Boolean isGeneratedFile; + @RuleProperty( key = "threshold", description = "The maximum authorized complexity.", @@ -43,7 +47,7 @@ public class CognitiveComplexityFunctionCheck extends PythonSubscriptionCheck { public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, ctx -> { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); - if (isInnerFunction(functionDef)) { + if (isInnerFunction(functionDef) || isGeneratedFile(ctx)) { return; } List secondaryLocations = new ArrayList<>(); @@ -57,6 +61,18 @@ public void initialize(Context context) { }); } + @Override + public void leaveFile() { + isGeneratedFile = null; + } + + private boolean isGeneratedFile(SubscriptionContext ctx) { + if (isGeneratedFile == null) { + isGeneratedFile = GeneratedFileUtils.isGeneratedFileForReadabilityRules(ctx.pythonFile(), ctx.syntaxNode()); + } + return isGeneratedFile; + } + private static boolean isInnerFunction(FunctionDef functionDef) { Tree parent = functionDef.parent(); while (parent != null) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/CollapsibleIfStatementsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CollapsibleIfStatementsCheck.java index c20c2b0b26..fc204fc40d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CollapsibleIfStatementsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CollapsibleIfStatementsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CollectionCreationWrappedInConstructorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CollectionCreationWrappedInConstructorCheck.java index e9ff371d2d..824e7d1af4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CollectionCreationWrappedInConstructorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CollectionCreationWrappedInConstructorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CollectionLengthComparisonCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CollectionLengthComparisonCheck.java index 96e8380d52..946dadbaf6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CollectionLengthComparisonCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CollectionLengthComparisonCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -20,19 +20,23 @@ import java.util.EnumSet; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.tree.BinaryExpression; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.NumericLiteral; import org.sonar.plugins.python.api.tree.Tree.Kind; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.api.PythonPunctuator; -import org.sonar.plugins.python.api.symbols.Symbol; import static org.sonar.python.checks.utils.Expressions.removeParentheses; @Rule(key = "S3981") public class CollectionLengthComparisonCheck extends PythonSubscriptionCheck { + private static final TypeMatcher LEN_MATCHER = TypeMatchers.isType("len"); + private static final EnumSet INVALID_OPERATORS = EnumSet.of(PythonPunctuator.LT, PythonPunctuator.GT_EQU); @@ -46,8 +50,8 @@ public void initialize(Context context) { Expression left = removeParentheses(comparison.leftOperand()); Expression right = removeParentheses(comparison.rightOperand()); TokenType operator = comparison.operator().type(); - if ((isCallToLen(left) && isZero(right) && INVALID_OPERATORS.contains(operator)) - || (isCallToLen(right) && isZero(left) && INVALID_REVERSE_OPERATORS.contains(operator))) { + if ((isCallToLen(left, ctx) && isZero(right) && INVALID_OPERATORS.contains(operator)) + || (isCallToLen(right, ctx) && isZero(left) && INVALID_REVERSE_OPERATORS.contains(operator))) { ctx.addIssue(comparison, "The length of a collection is always \">=0\", so update this test to either \"==0\" or \">0\"."); } }); @@ -57,12 +61,8 @@ private static boolean isZero(Expression expression) { return expression.is(Kind.NUMERIC_LITERAL) && "0".equals(((NumericLiteral) expression).valueAsString()); } - private static boolean isCallToLen(Expression expression) { - if (expression.is(Kind.CALL_EXPR)) { - Symbol calleeSymbol = ((CallExpression) expression).calleeSymbol(); - return calleeSymbol != null && "len".equals(calleeSymbol.fullyQualifiedName()); - } - return false; + private static boolean isCallToLen(Expression expression, SubscriptionContext ctx) { + return expression.is(Kind.CALL_EXPR) && LEN_MATCHER.isTrueFor(((CallExpression) expression).callee(), ctx); } diff --git a/python-checks/src/main/java/org/sonar/python/checks/CommentRegularExpressionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CommentRegularExpressionCheck.java index ebf8b56900..998672ca31 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CommentRegularExpressionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CommentRegularExpressionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CommentedCodeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CommentedCodeCheck.java index 69724a792c..e04c317558 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CommentedCodeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CommentedCodeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -33,6 +33,7 @@ import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.Trivia; import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.GeneratedFileUtils; import org.sonar.python.parser.PythonParser; import org.sonar.python.tree.PythonTreeMaker; @@ -50,6 +51,7 @@ public class CommentedCodeCheck extends PythonSubscriptionCheck { private final PythonParser parser = PythonParser.create(); private Pattern exceptionPattern; + private Boolean isGeneratedFile; @RuleProperty( key = "exception", @@ -62,6 +64,9 @@ public void initialize(Context context) { exceptionPattern = Pattern.compile(exception); context.registerSyntaxNodeConsumer(Tree.Kind.TOKEN, ctx -> { + if (isGeneratedFile(ctx)) { + return; + } Token token = (Token) ctx.syntaxNode(); List> groupedTrivias = groupTrivias(token); for (List triviaGroup : groupedTrivias) { @@ -70,6 +75,9 @@ public void initialize(Context context) { }); context.registerSyntaxNodeConsumer(Tree.Kind.STRING_LITERAL, ctx -> { + if (isGeneratedFile(ctx)) { + return; + } StringLiteral stringLiteral = (StringLiteral) ctx.syntaxNode(); if (isMultilineComment(stringLiteral)) { visitMultilineComment(stringLiteral, ctx); @@ -77,6 +85,18 @@ public void initialize(Context context) { }); } + @Override + public void leaveFile() { + isGeneratedFile = null; + } + + private boolean isGeneratedFile(SubscriptionContext ctx) { + if (isGeneratedFile == null) { + isGeneratedFile = GeneratedFileUtils.isGeneratedFileForReadabilityRules(ctx.pythonFile(), ctx.syntaxNode()); + } + return isGeneratedFile; + } + private static boolean isMultilineComment(StringLiteral stringLiteral) { Tree parent = stringLiteral.parent(); StringElement firstElement = stringLiteral.stringElements().get(0); diff --git a/python-checks/src/main/java/org/sonar/python/checks/ComparisonToNoneCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ComparisonToNoneCheck.java index c304892f32..3bdf18c6a5 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ComparisonToNoneCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ComparisonToNoneCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CompressionModulesFromNamespaceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CompressionModulesFromNamespaceCheck.java index a737fc0845..b2aeee661c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CompressionModulesFromNamespaceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CompressionModulesFromNamespaceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ConfusingTypeCheckingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ConfusingTypeCheckingCheck.java index 7421d049af..f755cada50 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ConfusingTypeCheckingCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ConfusingTypeCheckingCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ConfusingWalrusCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ConfusingWalrusCheck.java index b867557f3b..1893496c44 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ConfusingWalrusCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ConfusingWalrusCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ConsistentReturnCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ConsistentReturnCheck.java index 3af827e0f7..76d5ebb68d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ConsistentReturnCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ConsistentReturnCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -17,7 +17,6 @@ package org.sonar.python.checks; import java.util.List; -import java.util.stream.Collectors; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; @@ -40,16 +39,16 @@ public class ConsistentReturnCheck extends PythonSubscriptionCheck { public void initialize(Context context) { context.registerSyntaxNodeConsumer(Kind.FUNCDEF, ctx -> { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); - ControlFlowGraph cfg = ControlFlowGraph.build(functionDef, ctx.pythonFile()); + ControlFlowGraph cfg = ctx.cfg(functionDef); if (cfg == null || hasExceptOrFinally(cfg)) { return; } - List endStatements = cfg.end().predecessors().stream() + List endStatements = cfg.end().predecessors().stream() .map(block -> parentStatement(block.elements().get(block.elements().size() - 1))) .filter(s -> !s.is(Kind.RAISE_STMT, Kind.ASSERT_STMT, Kind.WITH_STMT) && !isWhileTrue(s)) - .collect(Collectors.toList()); + .toList(); - List returnsWithValue = endStatements.stream() + List returnsWithValue = endStatements.stream() .filter(s -> s.is(Kind.RETURN_STMT) && hasValue((ReturnStatement) s)) .toList(); @@ -68,9 +67,9 @@ private static boolean isWhileTrue(Statement statement) { return statement.is(Kind.WHILE_STMT) && Expressions.isTruthy(((WhileStatement) statement).condition()); } - private static void addIssue(SubscriptionContext ctx, FunctionDef functionDef, List endStatements) { + private static void addIssue(SubscriptionContext ctx, FunctionDef functionDef, List endStatements) { PreciseIssue issue = ctx.addIssue(functionDef.name(), MESSAGE); - for (Tree statement : endStatements) { + for (Statement statement : endStatements) { if (statement.is(Kind.RETURN_STMT)) { ReturnStatement returnStatement = (ReturnStatement) statement; boolean hasValue = hasValue(returnStatement); diff --git a/python-checks/src/main/java/org/sonar/python/checks/ConstantConditionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ConstantConditionCheck.java index 5afd481edf..2d265ec024 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ConstantConditionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ConstantConditionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -28,12 +28,10 @@ import org.sonar.plugins.python.api.tree.ComprehensionIf; import org.sonar.plugins.python.api.tree.ConditionalExpression; import org.sonar.plugins.python.api.tree.Expression; -import org.sonar.plugins.python.api.tree.FileInput; import org.sonar.plugins.python.api.tree.HasSymbol; import org.sonar.plugins.python.api.tree.IfStatement; import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.UnaryExpression; -import org.sonar.python.cfg.fixpoint.ReachingDefinitionsAnalysis; import static org.sonar.plugins.python.api.tree.Tree.Kind.AND; import static org.sonar.plugins.python.api.tree.Tree.Kind.NAME; @@ -48,13 +46,6 @@ public class ConstantConditionCheck extends PythonVisitorCheck { private static final String MESSAGE = "Replace this expression; used as a condition it will always be constant."; private static final List ACCEPTED_DECORATORS = List.of("overload", "staticmethod", "classmethod"); - private ReachingDefinitionsAnalysis reachingDefinitionsAnalysis; - - @Override - public void visitFileInput(FileInput fileInput) { - reachingDefinitionsAnalysis = new ReachingDefinitionsAnalysis(getContext().pythonFile()); - super.visitFileInput(fileInput); - } @Override public void visitIfStatement(IfStatement ifStatement) { @@ -143,7 +134,7 @@ private void checkExpression(Expression expression) { } } if (expression.is(NAME)) { - Set valuesAtLocation = reachingDefinitionsAnalysis.valuesAtLocation(((Name) expression)); + Set valuesAtLocation = getContext().valuesAtLocation(((Name) expression)); if (valuesAtLocation.size() == 1) { Expression lastAssignedValue = valuesAtLocation.iterator().next(); if (isImmutableConstant(lastAssignedValue)) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/ConstantValueDictComprehensionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ConstantValueDictComprehensionCheck.java index 17eb24edd0..c14c880e36 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ConstantValueDictComprehensionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ConstantValueDictComprehensionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ControlFlowInTaskGroupCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ControlFlowInTaskGroupCheck.java index 75329c100a..050c2e2b39 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ControlFlowInTaskGroupCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ControlFlowInTaskGroupCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/CorsMiddlewareOrderingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/CorsMiddlewareOrderingCheck.java index 988a3dc72f..eadfa8e241 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/CorsMiddlewareOrderingCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/CorsMiddlewareOrderingCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/DataClassFunctionCallDefaultCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DataClassFunctionCallDefaultCheck.java new file mode 100644 index 0000000000..91444c8535 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/DataClassFunctionCallDefaultCheck.java @@ -0,0 +1,224 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.Set; +import java.util.stream.Stream; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.SubscriptionExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.TypeAnnotation; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8685") +public class DataClassFunctionCallDefaultCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Use \"field(default_factory=...)\" instead of a function call as a default value."; + private static final String DEFAULT_KEYWORD = "default"; + + private static final TypeMatcher IS_DATACLASS_DECORATOR = TypeMatchers.isType("dataclasses.dataclass"); + private static final TypeMatcher IS_DATACLASSES_FIELD = TypeMatchers.isType("dataclasses.field"); + private static final TypeMatcher IS_CLASS_VAR = TypeMatchers.isType("typing.ClassVar"); + + // Allowlist of callables whose result should be re-evaluated per dataclass instance. + // Calls to anything outside this list are assumed safe (e.g. user-defined helpers, frozen-dataclass + // constructors, wrappers around dataclasses.field(default_factory=...)) — we prefer FNs over FPs here. + // + // NOTE: random.* top-level functions are intentionally absent. In typeshed they are aliased from a + // module-level Random() instance (`randint = _inst.randint`, ...) and the V2 typeshed serializer + // flattens the bound-method type to CallableType[builtins.function], so isType("random.randint") + // resolves through Unknown. They are matched separately below via the random module qualifier. + private static final TypeMatcher IS_PROBLEMATIC_FACTORY = TypeMatchers.any(Stream.of( + // Current time / clock readings + "datetime.datetime.now", + "datetime.datetime.utcnow", + "datetime.datetime.today", + "datetime.datetime.fromtimestamp", + "datetime.datetime.utcfromtimestamp", + "datetime.date.today", + "datetime.date.fromtimestamp", + "time.time", + "time.time_ns", + "time.monotonic", + "time.monotonic_ns", + "time.perf_counter", + "time.perf_counter_ns", + "time.process_time", + "time.process_time_ns", + "time.localtime", + "time.gmtime", + // UUIDs + "uuid.uuid1", + "uuid.uuid3", + "uuid.uuid4", + "uuid.uuid5", + // Secrets + "secrets.token_hex", + "secrets.token_bytes", + "secrets.token_urlsafe", + "secrets.choice", + "secrets.randbelow", + "secrets.randbits", + // OS randomness + "os.urandom", + // Mutable container constructors — shared across all instances otherwise + "builtins.list", + "builtins.dict", + "builtins.set", + "builtins.bytearray", + "collections.defaultdict", + "collections.OrderedDict", + "collections.Counter", + "collections.deque").map(TypeMatchers::isType)); + + // The random module type itself is known, even though its top-level function members all resolve + // to Unknown (see NOTE on IS_PROBLEMATIC_FACTORY). We match `.` syntactically. + private static final TypeMatcher IS_RANDOM_MODULE = TypeMatchers.isType("random"); + + private static final Set RANDOM_PROBLEMATIC_FUNCTION_NAMES = Set.of( + "random", + "randint", + "randrange", + "choice", + "choices", + "sample", + "uniform", + "gauss", + "normalvariate", + "triangular", + "betavariate", + "expovariate", + "gammavariate", + "lognormvariate", + "paretovariate", + "vonmisesvariate", + "weibullvariate", + "getrandbits", + "randbytes"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, DataClassFunctionCallDefaultCheck::checkClassDef); + } + + private static void checkClassDef(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + if (!isDataclass(classDef, ctx)) { + return; + } + classDef.body().statements().stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(AnnotatedAssignment.class)) + .forEach(annotatedAssignment -> checkField(ctx, annotatedAssignment)); + } + + private static boolean isDataclass(ClassDef classDef, SubscriptionContext ctx) { + for (Decorator decorator : classDef.decorators()) { + Expression decoratorExpr = getDecoratorFunctionExpression(decorator); + if (IS_DATACLASS_DECORATOR.isTrueFor(decoratorExpr, ctx)) { + return true; + } + } + return false; + } + + private static Expression getDecoratorFunctionExpression(Decorator decorator) { + Expression expr = decorator.expression(); + if (expr instanceof CallExpression callExpr) { + return callExpr.callee(); + } + return expr; + } + + private static void checkField(SubscriptionContext ctx, AnnotatedAssignment annotatedAssignment) { + Expression assignedValue = annotatedAssignment.assignedValue(); + if (assignedValue == null || isClassVar(annotatedAssignment.annotation(), ctx)) { + return; + } + if (isMutableLiteral(assignedValue)) { + ctx.addIssue(assignedValue, MESSAGE); + return; + } + if (assignedValue instanceof CallExpression callExpression) { + Tree problematic = problematicCall(callExpression, ctx); + if (problematic != null) { + ctx.addIssue(problematic, MESSAGE); + } + } + } + + private static boolean isMutableLiteral(Expression expression) { + return expression.is(Tree.Kind.LIST_LITERAL, Tree.Kind.DICTIONARY_LITERAL, Tree.Kind.SET_LITERAL); + } + + // Returns the expression to flag, or null. Handles all of: + // x: T = datetime.now() -> the outer call + // x: T = field(default=datetime.now()) -> the inner default argument + // x: T = field(default=[]) -> the inner mutable literal + private static Tree problematicCall(CallExpression callExpression, SubscriptionContext ctx) { + if (isProblematicFactoryCall(callExpression, ctx)) { + return callExpression; + } + if (IS_DATACLASSES_FIELD.isTrueFor(callExpression.callee(), ctx)) { + RegularArgument defaultArg = TreeUtils.argumentByKeyword(DEFAULT_KEYWORD, callExpression.arguments()); + if (defaultArg != null) { + Expression defaultExpr = defaultArg.expression(); + if (isMutableLiteral(defaultExpr)) { + return defaultExpr; + } + if (defaultExpr instanceof CallExpression innerCall && isProblematicFactoryCall(innerCall, ctx)) { + return innerCall; + } + } + } + return null; + } + + private static boolean isProblematicFactoryCall(CallExpression callExpression, SubscriptionContext ctx) { + Expression callee = callExpression.callee(); + return IS_PROBLEMATIC_FACTORY.isTrueFor(callee, ctx) || isRandomModuleFunctionCall(callee, ctx); + } + + // Workaround for the random.* alias gap in the V2 typeshed serializer (see NOTE on + // IS_PROBLEMATIC_FACTORY): the random module type itself is known, so we recognise + // a problematic call by checking the qualifier's type and the syntactic name. + private static boolean isRandomModuleFunctionCall(Expression callee, SubscriptionContext ctx) { + if (!(callee instanceof QualifiedExpression qualifiedExpression)) { + return false; + } + return RANDOM_PROBLEMATIC_FUNCTION_NAMES.contains(qualifiedExpression.name().name()) + && IS_RANDOM_MODULE.isTrueFor(qualifiedExpression.qualifier(), ctx); + } + + private static boolean isClassVar(TypeAnnotation annotation, SubscriptionContext ctx) { + Expression annotationExpr = annotation.expression(); + if (annotationExpr instanceof SubscriptionExpression subscriptionExpr) { + return IS_CLASS_VAR.isTrueFor(subscriptionExpr.object(), ctx); + } + return IS_CLASS_VAR.isTrueFor(annotationExpr, ctx); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/DataClassOnEnumCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DataClassOnEnumCheck.java new file mode 100644 index 0000000000..45df3120a8 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/DataClassOnEnumCheck.java @@ -0,0 +1,72 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S8490") +public class DataClassOnEnumCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove this \"@dataclass\" decorator; it is incompatible with Enum classes."; + + private static final TypeMatcher IS_ENUM_MATCHER = TypeMatchers.any( + TypeMatchers.isOrExtendsType("enum.Enum"), + TypeMatchers.isOrExtendsType("enum.IntEnum"), + TypeMatchers.isOrExtendsType("enum.IntFlag")); + private static final TypeMatcher IS_DATACLASS_MATCHER = TypeMatchers.isType("dataclasses.dataclass"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, DataClassOnEnumCheck::checkClassDef); + } + + private static void checkClassDef(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + + if (classDef.decorators().isEmpty()) { + return; + } + + if (!IS_ENUM_MATCHER.isTrueFor(classDef.name(), ctx)) { + return; + } + + for (Decorator decorator : classDef.decorators()) { + Expression decoratorExpr = getDecoratorFunctionExpression(decorator); + if (IS_DATACLASS_MATCHER.isTrueFor(decoratorExpr, ctx)) { + ctx.addIssue(decorator, MESSAGE); + } + } + } + + private static Expression getDecoratorFunctionExpression(Decorator decorator) { + Expression expr = decorator.expression(); + if (expr instanceof CallExpression callExpr) { + return callExpr.callee(); + } + return expr; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/DataclassFieldDefinitionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DataclassFieldDefinitionCheck.java new file mode 100644 index 0000000000..f00de87a2e --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/DataclassFieldDefinitionCheck.java @@ -0,0 +1,102 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S8514") +public class DataclassFieldDefinitionCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE_MISSING_ANNOTATION = "Add a type annotation to this dataclass attribute."; + + private static final TypeMatcher IS_DATACLASS = TypeMatchers.isType("dataclasses.dataclass"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, DataclassFieldDefinitionCheck::checkClassDef); + } + + private static void checkClassDef(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + + if (!isDataclass(classDef, ctx)) { + return; + } + + classDef.body().statements().forEach(statement -> checkStatement(ctx, statement)); + } + + private static boolean isDataclass(ClassDef classDef, SubscriptionContext ctx) { + return classDef.decorators().stream().anyMatch(decorator -> isDataclassDecorator(decorator, ctx)); + } + + private static boolean isDataclassDecorator(Decorator decorator, SubscriptionContext ctx) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpr) { + return IS_DATACLASS.isTrueFor(callExpr.callee(), ctx); + } + return IS_DATACLASS.isTrueFor(expression, ctx); + } + + private static void checkStatement(SubscriptionContext ctx, Tree statement) { + if (statement instanceof AssignmentStatement assignmentStatement && !isLikelyIntentionalClassVar(assignmentStatement)) { + ctx.addIssue(assignmentStatement, MESSAGE_MISSING_ANNOTATION); + } + } + + private static boolean isLikelyIntentionalClassVar(AssignmentStatement assignment) { + List lhsList = assignment.lhsExpressions(); + if (lhsList.size() != 1) { + return false; + } + List expressions = lhsList.get(0).expressions(); + if (expressions.size() != 1 || !expressions.get(0).is(Tree.Kind.NAME)) { + return false; + } + String name = ((Name) expressions.get(0)).name(); + return name.startsWith("_") || isAllCaps(name); + } + + // ALL_CAPS names follow the Python constant convention — they are intentional class-level attributes. + private static boolean isAllCaps(String name) { + if (name.isEmpty()) { + return false; + } + boolean hasUpperCase = false; + for (char c : name.toCharArray()) { + if (Character.isUpperCase(c)) { + hasUpperCase = true; + } else if (!Character.isDigit(c) && c != '_') { + return false; + } + } + return hasUpperCase; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/DbNoPasswordCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DbNoPasswordCheck.java index 33e2baa3d2..1534471358 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DbNoPasswordCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DbNoPasswordCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,14 +16,12 @@ */ package org.sonar.python.checks; -import java.util.Arrays; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.Argument; import org.sonar.plugins.python.api.tree.AssignmentStatement; import org.sonar.plugins.python.api.tree.CallExpression; @@ -34,6 +32,8 @@ import org.sonar.plugins.python.api.tree.StringLiteral; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.Tree.Kind; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import static org.sonar.plugins.python.api.tree.Tree.Kind.ASSIGNMENT_STMT; import static org.sonar.plugins.python.api.tree.Tree.Kind.CALL_EXPR; @@ -49,15 +49,19 @@ public class DbNoPasswordCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Add password protection to this database."; - private static final List CONNECT_METHODS = Arrays.asList( - "mysql.connector.connect", - "mysql.connector.connection.MySQLConnection", - "pymysql.connections.connect", - "psycopg2.connect", - "pgdb.connect.connect", - "pg.DB", - "pg.connect" - ); + private static final TypeMatcher PG_MATCHER = TypeMatchers.any( + TypeMatchers.isType("pg.db.DB"), + TypeMatchers.isType("pg.connect")); + + private static final TypeMatcher CONNECT_MATCHER = TypeMatchers.any( + TypeMatchers.isType("mysql.connector.connect"), + TypeMatchers.isType("mysql.connector.connection.MySQLConnection"), + TypeMatchers.isType("pymysql.connections.connect"), + TypeMatchers.isType("psycopg2.connect"), + // pgdb.connect is a module whose connect function has FQN pgdb.connect.connect. + // isType can't resolve it through the type table, so use withFQN to match on the FQN directly. + TypeMatchers.withFQN("pgdb.connect.connect"), + PG_MATCHER); private static final Pattern CONNECTION_URI_PATTERN = Pattern.compile("^(?:postgresql|mysql|oracle|mssql)(?:\\+.+?)?://.+?(:.*)?@.+"); @@ -83,17 +87,17 @@ private static void checkDbUri(SubscriptionContext ctx) { private static void checkDbApi(SubscriptionContext ctx) { CallExpression callExpr = (CallExpression) ctx.syntaxNode(); - Symbol symbol = callExpr.calleeSymbol(); - if (symbol != null && CONNECT_METHODS.contains(symbol.fullyQualifiedName())) { - RegularArgument passwordArgument = getPasswordArgument(symbol.fullyQualifiedName(), callExpr.arguments()); - if (passwordArgument != null && isString(passwordArgument.expression(), "")) { - ctx.addIssue(passwordArgument, MESSAGE); - } + if (!CONNECT_MATCHER.isTrueFor(callExpr.callee(), ctx)) { + return; + } + boolean isPg = PG_MATCHER.isTrueFor(callExpr.callee(), ctx); + RegularArgument passwordArgument = getPasswordArgument(isPg, callExpr.arguments()); + if (passwordArgument != null && isString(passwordArgument.expression(), "")) { + ctx.addIssue(passwordArgument, MESSAGE); } } - private static RegularArgument getPasswordArgument(String method, List arguments) { - boolean isPg = method.startsWith("pg."); + private static RegularArgument getPasswordArgument(boolean isPg, List arguments) { String argumentKeyword = isPg ? "passwd" : "password"; int passwordIndex = isPg ? 5 : 2; int positionalIndex = 0; diff --git a/python-checks/src/main/java/org/sonar/python/checks/DeadStoreCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DeadStoreCheck.java index 6427b3133a..b6aaa353b4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DeadStoreCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DeadStoreCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -55,55 +55,11 @@ @Rule(key = "S1854") public class DeadStoreCheck extends PythonSubscriptionCheck { + public static final String QUICK_FIX_MESSAGE = "Remove the unused assignment"; private static final String MESSAGE_TEMPLATE = "Remove this assignment to local variable '%s'; the value is never used."; - private static final String SECONDARY_MESSAGE_TEMPLATE = "'%s' is reassigned here."; - public static final String QUICK_FIX_MESSAGE = "Remove the unused assignment"; - private boolean isTemplateVariablesAccessEnabled = false; - @Override - public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, this::checkTemplateVariablesAccessEnabled); - context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, ctx -> { - FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); - if (TreeUtils.hasDescendant(functionDef, tree -> tree.is(Tree.Kind.TRY_STMT))) { - return; - } - ControlFlowGraph cfg = ControlFlowGraph.build(functionDef, ctx.pythonFile()); - if (cfg == null) { - return; - } - LiveVariablesAnalysis lva = LiveVariablesAnalysis.analyze(cfg); - cfg.blocks().forEach(block -> verifyBlock(ctx, block, lva.getLiveVariables(block), lva.getReadSymbols(), functionDef)); - }); - } - - private void checkTemplateVariablesAccessEnabled(SubscriptionContext ctx) { - var importedNamesCollector = new ImportedNamesCollector(); - importedNamesCollector.collect(ctx.syntaxNode()); - isTemplateVariablesAccessEnabled = importedNamesCollector.anyMatches("pandas"::equals); - } - - /** - * Bottom-up approach, keeping track of which variables will be read by successor elements. - */ - private void verifyBlock(SubscriptionContext ctx, CfgBlock block, LiveVariablesAnalysis.LiveVariables blockLiveVariables, - Set readSymbols, FunctionDef functionDef) { - - var stringLiteralValuesCollector = new StringLiteralValuesCollector(); - if (isTemplateVariablesAccessEnabled) { - stringLiteralValuesCollector.collect(functionDef); - } - DeadStoreUtils.findUnnecessaryAssignments(block, blockLiveVariables, functionDef) - .stream() - // symbols should have at least one read usage (otherwise will be reported by S1481) - .filter(unnecessaryAssignment -> readSymbols.contains(unnecessaryAssignment.symbol)) - .filter((unnecessaryAssignment -> !isException(unnecessaryAssignment.symbol, unnecessaryAssignment.element, functionDef, - stringLiteralValuesCollector))) - .forEach(unnecessaryAssignment -> raiseIssue(ctx, unnecessaryAssignment)); - } - private static void raiseIssue(SubscriptionContext ctx, DeadStoreUtils.UnnecessaryAssignment unnecessaryAssignment) { Tree element; if (unnecessaryAssignment.element instanceof ClassDef classDefElement) { @@ -247,7 +203,6 @@ private static boolean isFunctionDeclarationSymbol(Symbol symbol) { return symbol.usages().stream().anyMatch(u -> u.kind() == Usage.Kind.FUNC_DECLARATION); } - private static boolean isExceptionForQuickFix(Statement tree) { switch (tree.getKind()) { // foo:str = bar @@ -265,6 +220,51 @@ private static boolean isExceptionForQuickFix(Statement tree) { } } + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, this::checkTemplateVariablesAccessEnabled); + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, ctx -> { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + if (TreeUtils.hasDescendant(functionDef, tree -> tree.is(Tree.Kind.TRY_STMT))) { + return; + } + ControlFlowGraph cfg = ctx.cfg(functionDef); + if (cfg == null) { + return; + } + LiveVariablesAnalysis lva = ctx.lva(functionDef); + if (lva == null) { + return; + } + cfg.blocks().forEach(block -> verifyBlock(ctx, block, lva.getLiveVariables(block), lva.getReadSymbols(), functionDef)); + }); + } + + private void checkTemplateVariablesAccessEnabled(SubscriptionContext ctx) { + var importedNamesCollector = new ImportedNamesCollector(); + importedNamesCollector.collect(ctx.syntaxNode()); + isTemplateVariablesAccessEnabled = importedNamesCollector.anyMatches("pandas"::equals); + } + + /** + * Bottom-up approach, keeping track of which variables will be read by successor elements. + */ + private void verifyBlock(SubscriptionContext ctx, CfgBlock block, LiveVariablesAnalysis.LiveVariables blockLiveVariables, + Set readSymbols, FunctionDef functionDef) { + + var stringLiteralValuesCollector = new StringLiteralValuesCollector(); + if (isTemplateVariablesAccessEnabled) { + stringLiteralValuesCollector.collect(functionDef); + } + DeadStoreUtils.findUnnecessaryAssignments(block, blockLiveVariables, functionDef) + .stream() + // symbols should have at least one read usage (otherwise will be reported by S1481) + .filter(unnecessaryAssignment -> readSymbols.contains(unnecessaryAssignment.symbol)) + .filter((unnecessaryAssignment -> !isException(unnecessaryAssignment.symbol, unnecessaryAssignment.element, functionDef, + stringLiteralValuesCollector))) + .forEach(unnecessaryAssignment -> raiseIssue(ctx, unnecessaryAssignment)); + } + private static class SideEffectDetector extends BaseTreeVisitor { private boolean sideEffect = false; diff --git a/python-checks/src/main/java/org/sonar/python/checks/DefaultFactoryArgumentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DefaultFactoryArgumentCheck.java index d84e151b17..9908472600 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DefaultFactoryArgumentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DefaultFactoryArgumentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/DeprecatedNumpyTypesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DeprecatedNumpyTypesCheck.java index d08041d29c..b4e1aa26bd 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DeprecatedNumpyTypesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DeprecatedNumpyTypesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,15 +16,15 @@ */ package org.sonar.python.checks; -import java.util.Map; -import java.util.Optional; +import java.util.List; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.quickfix.PythonQuickFix; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.QualifiedExpression; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.quickfix.TextEditUtils; @Rule(key = "S6730") @@ -32,15 +32,17 @@ public class DeprecatedNumpyTypesCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Replace this deprecated \"numpy\" type alias with the builtin type \"%s\"."; private static final String QUICK_FIX_MESSAGE = "Replace with %s."; - private static final Map TYPE_TO_CHECK = Map.of( - "numpy.bool", "bool", - "numpy.int", "int", - "numpy.float", "float", - "numpy.complex", "complex", - "numpy.object", "object", - "numpy.str", "str", - "numpy.long", "int", - "numpy.unicode", "str"); + + private record DeprecatedType(TypeMatcher matcher, String replacement) {} + + private static final List DEPRECATED_TYPES = List.of( + new DeprecatedType(TypeMatchers.withFQN("numpy.int"), "int"), + new DeprecatedType(TypeMatchers.withFQN("numpy.float"), "float"), + new DeprecatedType(TypeMatchers.withFQN("numpy.complex"), "complex"), + new DeprecatedType(TypeMatchers.withFQN("numpy.object"), "object"), + new DeprecatedType(TypeMatchers.withFQN("numpy.str"), "str"), + new DeprecatedType(TypeMatchers.withFQN("numpy.long"), "int"), + new DeprecatedType(TypeMatchers.withFQN("numpy.unicode"), "str")); @Override public void initialize(Context context) { @@ -50,13 +52,15 @@ public void initialize(Context context) { private static void checkForDeprecatedTypesNames(SubscriptionContext ctx) { QualifiedExpression expression = (QualifiedExpression) ctx.syntaxNode(); - Optional.ofNullable(expression.symbol()) - .map(Symbol::fullyQualifiedName) - .map(TYPE_TO_CHECK::get) - .ifPresent(type -> raiseIssue(expression, type, ctx)); + for (DeprecatedType deprecatedType : DEPRECATED_TYPES) { + if (deprecatedType.matcher().isTrueFor(expression, ctx)) { + raiseIssue(expression, deprecatedType.replacement(), ctx); + return; + } + } } - private static void raiseIssue(Tree expression, String replacementType, SubscriptionContext ctx) { + private static void raiseIssue(QualifiedExpression expression, String replacementType, SubscriptionContext ctx) { PreciseIssue issue = ctx.addIssue(expression, String.format(MESSAGE, replacementType)); PythonQuickFix quickFix = PythonQuickFix.newQuickFix( String.format(QUICK_FIX_MESSAGE, replacementType), diff --git a/python-checks/src/main/java/org/sonar/python/checks/DictKeysMembershipTestCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DictKeysMembershipTestCheck.java new file mode 100644 index 0000000000..01a6bc9fd8 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/DictKeysMembershipTestCheck.java @@ -0,0 +1,62 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.InExpression; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S8521") +public class DictKeysMembershipTestCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove this unnecessary \"keys()\" call."; + private static final String KEYS_METHOD_NAME = "keys"; + private static final TypeMatcher DICT_OR_SUBCLASS_KEYS_MATCHER = + TypeMatchers.isFunctionOwnerSatisfying(TypeMatchers.isOrExtendsType("builtins.dict")); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.IN, DictKeysMembershipTestCheck::checkInExpression); + } + + private static void checkInExpression(SubscriptionContext ctx) { + InExpression inExpression = (InExpression) ctx.syntaxNode(); + if (!(inExpression.rightOperand() instanceof CallExpression callExpression)) { + return; + } + if (!callExpression.arguments().isEmpty()) { + return; + } + if (!isKeysCall(callExpression)) { + return; + } + if (DICT_OR_SUBCLASS_KEYS_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + ctx.addIssue(callExpression, MESSAGE); + } + } + + private static boolean isKeysCall(CallExpression callExpression) { + return callExpression.callee() instanceof QualifiedExpression qualifiedExpression + && KEYS_METHOD_NAME.equals(qualifiedExpression.name().name()); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/DictionaryDuplicateKeyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DictionaryDuplicateKeyCheck.java index 75c2169852..6d622ecc48 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DictionaryDuplicateKeyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DictionaryDuplicateKeyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/DictionaryStaticKeyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DictionaryStaticKeyCheck.java index 2aafc43bfe..a787bae10e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DictionaryStaticKeyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DictionaryStaticKeyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/DirectTypeComparisonCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DirectTypeComparisonCheck.java index deb3a15641..ebea455369 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DirectTypeComparisonCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DirectTypeComparisonCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -20,15 +20,13 @@ import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.BinaryExpression; -import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.Token; +import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; import static org.sonar.plugins.python.api.symbols.Symbol.Kind.CLASS; -import static org.sonar.plugins.python.api.tree.Tree.Kind.CALL_EXPR; import static org.sonar.plugins.python.api.tree.Tree.Kind.COMPARISON; @Rule(key = "S6660") @@ -53,13 +51,7 @@ private static void checkBinaryExpression(SubscriptionContext ctx, BinaryExpress } private static boolean isDirectTypeComparison(Expression lhs, Expression rhs) { - return (isTypeBuiltinCall(lhs) && TreeUtils.getSymbolFromTree(rhs).filter(s -> s.is(CLASS)).isPresent()) - || (isTypeBuiltinCall(rhs) && TreeUtils.getSymbolFromTree(lhs).filter(s -> s.is(CLASS)).isPresent()); - } - - private static boolean isTypeBuiltinCall(Expression expression) { - if (!expression.is(CALL_EXPR)) return false; - Symbol calleeSymbol = ((CallExpression) expression).calleeSymbol(); - return calleeSymbol != null && "type".equals(calleeSymbol.fullyQualifiedName()); + return (Expressions.isBuiltinTypeCall(lhs) && TreeUtils.getSymbolFromTree(rhs).filter(s -> s.is(CLASS)).isPresent()) + || (Expressions.isBuiltinTypeCall(rhs) && TreeUtils.getSymbolFromTree(lhs).filter(s -> s.is(CLASS)).isPresent()); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/DjangoNonDictSerializationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DjangoNonDictSerializationCheck.java index 1bc5fc7d9d..27254a9cca 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DjangoNonDictSerializationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DjangoNonDictSerializationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/DjangoRenderContextCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DjangoRenderContextCheck.java index b78f77e3d4..fc95de644c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DjangoRenderContextCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DjangoRenderContextCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/DoublePrefixOperatorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DoublePrefixOperatorCheck.java index 7ea28d62e4..cabf38be9c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DoublePrefixOperatorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DoublePrefixOperatorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -23,7 +23,8 @@ import org.sonar.plugins.python.api.tree.ParenthesizedExpression; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.UnaryExpression; -import org.sonar.python.types.InferredTypes; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; @Rule(key = "S2761") @@ -31,6 +32,7 @@ public class DoublePrefixOperatorCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Use the \"%s\" operator just once or not at all."; private static final String MESSAGE_NOT = "Use the \"bool()\" builtin function instead of calling \"not\" twice."; + private static final TypeMatcher IS_INT = TypeMatchers.isObjectOfType("builtins.int"); @Override public void initialize(Context context) { @@ -52,7 +54,7 @@ private static void doubleInversionCheck(SubscriptionContext ctx, UnaryExpressio if (invertedExpr.is(Tree.Kind.NOT)) { ctx.addIssue(original, MESSAGE_NOT); } else { - if (((UnaryExpression) invertedExpr).expression().type() == InferredTypes.INT) { + if (IS_INT.isTrueFor(((UnaryExpression) invertedExpr).expression(), ctx)) { ctx.addIssue(original, String.format(MESSAGE, original.operator().value())); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/DuplicateArgumentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DuplicateArgumentCheck.java index 309d6a421a..bd41c95752 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DuplicateArgumentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DuplicateArgumentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/DuplicateBaseClassCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DuplicateBaseClassCheck.java new file mode 100644 index 0000000000..d49223bcb6 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/DuplicateBaseClassCheck.java @@ -0,0 +1,87 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import javax.annotation.CheckForNull; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.ArgList; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.FullyQualifiedNameHelper; + +@Rule(key = "S8509") +public class DuplicateBaseClassCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove this duplicate base class."; + private static final String SECONDARY_MESSAGE = "Already listed here."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, ctx -> checkClassDef((ClassDef) ctx.syntaxNode(), ctx)); + } + + private static void checkClassDef(ClassDef classDef, SubscriptionContext ctx) { + ArgList args = classDef.args(); + if (args == null) { + return; + } + var duplicates = gatherDuplicates(args); + raiseOnDuplicates(duplicates, ctx); + } + + private static Map> gatherDuplicates(ArgList args) { + Map> groups = new LinkedHashMap<>(); + for (Argument argument : args.arguments()) { + if (argument instanceof RegularArgument regularArgument) { + if (regularArgument.keywordArgument() != null) { + continue; + } + String key = expressionKey(regularArgument.expression()); + if (key != null) { + groups.computeIfAbsent(key, k -> new ArrayList<>()).add(regularArgument); + } + } + } + return groups; + } + + private static void raiseOnDuplicates(Map> duplicates, SubscriptionContext ctx) { + for (List group : duplicates.values()) { + if (group.size() > 1) { + RegularArgument first = group.get(0); + PreciseIssue issue = ctx.addIssue(first.expression(), MESSAGE); + for (int i = 1; i < group.size(); i++) { + issue.secondary(group.get(i).expression(), SECONDARY_MESSAGE); + } + } + } + } + + @CheckForNull + private static String expressionKey(Expression expression) { + return FullyQualifiedNameHelper.getFullyQualifiedName(expression.typeV2()).orElse(null); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/DuplicatedMethodFieldNamesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DuplicatedMethodFieldNamesCheck.java index b09a8ab93f..5974290dce 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DuplicatedMethodFieldNamesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DuplicatedMethodFieldNamesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/DuplicatedMethodImplementationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/DuplicatedMethodImplementationCheck.java index da330dda2b..c5e4ea45bb 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/DuplicatedMethodImplementationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/DuplicatedMethodImplementationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/EinopsSyntaxCheck.java b/python-checks/src/main/java/org/sonar/python/checks/EinopsSyntaxCheck.java index baf45b8900..3c0b66e14b 100755 --- a/python-checks/src/main/java/org/sonar/python/checks/EinopsSyntaxCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/EinopsSyntaxCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ElseAfterLoopsWithoutBreakCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ElseAfterLoopsWithoutBreakCheck.java index be37249f5a..23f6796cf8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ElseAfterLoopsWithoutBreakCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ElseAfterLoopsWithoutBreakCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/EmptyCollectionConstructorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/EmptyCollectionConstructorCheck.java index 3cd6ce7f1b..7b754ea312 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/EmptyCollectionConstructorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/EmptyCollectionConstructorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/EmptyCollectionMembershipTestCheck.java b/python-checks/src/main/java/org/sonar/python/checks/EmptyCollectionMembershipTestCheck.java new file mode 100644 index 0000000000..e385b1c6dd --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/EmptyCollectionMembershipTestCheck.java @@ -0,0 +1,72 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.DictionaryLiteral; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.InExpression; +import org.sonar.plugins.python.api.tree.ListLiteral; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.Tuple; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S8503") +public class EmptyCollectionMembershipTestCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove this membership test on an empty collection; it will always be the same value."; + + private static final TypeMatcher EMPTY_COLLECTION_CONSTRUCTOR = TypeMatchers.any( + TypeMatchers.isType("builtins.set"), + TypeMatchers.isType("builtins.tuple"), + TypeMatchers.isType("builtins.frozenset") + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.IN, EmptyCollectionMembershipTestCheck::checkInExpression); + } + + private static void checkInExpression(SubscriptionContext ctx) { + InExpression inExpression = (InExpression) ctx.syntaxNode(); + Expression rightOperand = inExpression.rightOperand(); + if (isEmptyCollection(rightOperand, ctx)) { + ctx.addIssue(inExpression, MESSAGE); + } + } + + private static boolean isEmptyCollection(Expression expression, SubscriptionContext ctx) { + if (expression instanceof ListLiteral listLiteral) { + return listLiteral.elements().expressions().isEmpty(); + } + if (expression instanceof DictionaryLiteral dictionaryLiteral) { + return dictionaryLiteral.elements().isEmpty(); + } + if (expression instanceof Tuple tuple) { + return tuple.elements().isEmpty(); + } + if (expression instanceof CallExpression callExpression) { + return callExpression.arguments().isEmpty() + && EMPTY_COLLECTION_CONSTRUCTOR.isTrueFor(callExpression.callee(), ctx); + } + return false; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/EmptyFunctionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/EmptyFunctionCheck.java index c9a68cb5db..6c03821d10 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/EmptyFunctionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/EmptyFunctionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/EmptyNestedBlockCheck.java b/python-checks/src/main/java/org/sonar/python/checks/EmptyNestedBlockCheck.java index 4958ed63fb..ee4f608de2 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/EmptyNestedBlockCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/EmptyNestedBlockCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/EnumerateUnpackingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/EnumerateUnpackingCheck.java new file mode 100644 index 0000000000..e3a9b17c02 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/EnumerateUnpackingCheck.java @@ -0,0 +1,143 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.CompoundAssignmentStatement; +import org.sonar.plugins.python.api.tree.DelStatement; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.ForStatement; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.NumericLiteral; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.SubscriptionExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8518") +public class EnumerateUnpackingCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Unpack the value from 'enumerate()' directly instead of using an index lookup."; + private static final String SECONDARY_MESSAGE = "Replace this index lookup with the unpacked value."; + private static final TypeMatcher ENUMERATE_MATCHER = TypeMatchers.isType("enumerate"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FOR_STMT, EnumerateUnpackingCheck::check); + } + + private static void check(SubscriptionContext ctx) { + ForStatement forStatement = (ForStatement) ctx.syntaxNode(); + + if (forStatement.testExpressions().size() != 1) { + return; + } + if (!(forStatement.testExpressions().get(0) instanceof CallExpression call)) { + return; + } + if (!ENUMERATE_MATCHER.isTrueFor(call.callee(), ctx)) { + return; + } + if (forStatement.expressions().size() != 2) { + return; + } + if (!(forStatement.expressions().get(0) instanceof Name indexName)) { + return; + } + SymbolV2 indexSymbol = indexName.symbolV2(); + if (indexSymbol == null) { + return; + } + + RegularArgument startArg = TreeUtils.nthArgumentOrKeyword(1, "start", call.arguments()); + if (startArg != null && !(startArg.expression() instanceof NumericLiteral num && "0".equals(num.valueAsString()))) { + return; + } + + RegularArgument iterableArg = TreeUtils.nthArgumentOrKeyword(0, "iterable", call.arguments()); + if (iterableArg == null || !(iterableArg.expression() instanceof Name iterableName)) { + return; + } + SymbolV2 iterableSymbol = iterableName.symbolV2(); + if (iterableSymbol == null) { + return; + } + + List matchingSubscripts = new ArrayList<>(); + collectMatchingSubscripts(forStatement.body(), indexSymbol, iterableSymbol, matchingSubscripts); + + if (matchingSubscripts.isEmpty()) { + return; + } + if (matchingSubscripts.stream().anyMatch(EnumerateUnpackingCheck::isSubscriptWriteTarget)) { + return; + } + + PreciseIssue issue = ctx.addIssue(call, MESSAGE); + matchingSubscripts.forEach(subscript -> issue.secondary(subscript, SECONDARY_MESSAGE)); + } + + private static void collectMatchingSubscripts(Tree tree, SymbolV2 indexSymbol, SymbolV2 iterableSymbol, List result) { + for (Tree child : tree.children()) { + if (child instanceof SubscriptionExpression subscription && isMatchingSubscript(subscription, indexSymbol, iterableSymbol)) { + result.add(subscription); + } + collectMatchingSubscripts(child, indexSymbol, iterableSymbol, result); + } + } + + private static boolean isMatchingSubscript(SubscriptionExpression subscription, SymbolV2 indexSymbol, SymbolV2 iterableSymbol) { + if (subscription.subscripts().expressions().size() != 1) { + return false; + } + if (!(subscription.subscripts().expressions().get(0) instanceof Name subscriptName)) { + return false; + } + if (!indexSymbol.equals(subscriptName.symbolV2())) { + return false; + } + if (!(subscription.object() instanceof Name objectName)) { + return false; + } + return iterableSymbol.equals(objectName.symbolV2()); + } + + private static boolean isSubscriptWriteTarget(SubscriptionExpression subscription) { + Tree parent = subscription.parent(); + if (parent instanceof DelStatement) { + return true; + } + if (parent instanceof CompoundAssignmentStatement compound) { + return compound.lhsExpression() == subscription; + } + if (parent instanceof AnnotatedAssignment annotated) { + return annotated.variable() == subscription; + } + return parent instanceof ExpressionList exprList + && exprList.parent() instanceof AssignmentStatement; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/ExceptRethrowingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ExceptRethrowingCheck.java index bfa77475dd..88d2dc338a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ExceptRethrowingCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ExceptRethrowingCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ExceptionCauseTypeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ExceptionCauseTypeCheck.java index 209b61a691..e34a290b08 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ExceptionCauseTypeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ExceptionCauseTypeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ExceptionGroupCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ExceptionGroupCheck.java index d346f6dd25..111a36b9a1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ExceptionGroupCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ExceptionGroupCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ExceptionNotThrownCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ExceptionNotThrownCheck.java index 3a5b5052df..25d0be4833 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ExceptionNotThrownCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ExceptionNotThrownCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ExceptionSuperClassDeclarationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ExceptionSuperClassDeclarationCheck.java index 19b8b2620d..b249ba8ffd 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ExceptionSuperClassDeclarationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ExceptionSuperClassDeclarationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ExecStatementUsageCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ExecStatementUsageCheck.java index 1d31b239b0..777d48541e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ExecStatementUsageCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ExecStatementUsageCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ExitHasBadArgumentsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ExitHasBadArgumentsCheck.java index 49db585c41..ac1d1fb030 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ExitHasBadArgumentsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ExitHasBadArgumentsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FStringNestingLevelCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FStringNestingLevelCheck.java index 1534ad301d..e031373cbb 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FStringNestingLevelCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FStringNestingLevelCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FastAPIDependencyAnnotatedCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FastAPIDependencyAnnotatedCheck.java index a2bc11c3cb..12acb5df04 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FastAPIDependencyAnnotatedCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FastAPIDependencyAnnotatedCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,6 +16,8 @@ */ package org.sonar.python.checks; +import java.util.ArrayList; +import java.util.List; import java.util.Set; import java.util.stream.Stream; import javax.annotation.Nullable; @@ -26,7 +28,6 @@ import org.sonar.plugins.python.api.tree.Decorator; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.FunctionDef; -import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.Parameter; import org.sonar.plugins.python.api.tree.ParameterList; import org.sonar.plugins.python.api.tree.SubscriptionExpression; @@ -34,11 +35,17 @@ import org.sonar.plugins.python.api.tree.TypeAnnotation; import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; @Rule(key = "S8410") public class FastAPIDependencyAnnotatedCheck extends PythonSubscriptionCheck { + enum IssueReportingMode { + FILE_LOCAL_HEURISTIC, + DISABLE_FILE_LOCAL_SUPPRESSION + } + private static final String MESSAGE = "Use \"Annotated\" type hints for FastAPI dependency injection"; private static final Set ROUTES = Set.of( @@ -67,13 +74,46 @@ public class FastAPIDependencyAnnotatedCheck extends PythonSubscriptionCheck { ); private static final TypeMatcher TYPING_ANNOTATED_MATCHER = TypeMatchers.isType("typing.Annotated"); + private static final Set ANNOTATED_FULLY_QUALIFIED_NAMES = Set.of( + "typing.Annotated", + "typing_extensions.Annotated" + ); + + private final IssueReportingMode issueReportingMode; + private final List pendingIssues = new ArrayList<>(); + private SubscriptionContext fileContext; + private int annotatedStyleCount; + private int oldStyleCount; + + public FastAPIDependencyAnnotatedCheck() { + this(IssueReportingMode.FILE_LOCAL_HEURISTIC); + } + + FastAPIDependencyAnnotatedCheck(IssueReportingMode issueReportingMode) { + this.issueReportingMode = issueReportingMode; + } @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, FastAPIDependencyAnnotatedCheck::checkFunctionDef); + context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, this::resetFileState); + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, this::checkFunctionDef); } - private static void checkFunctionDef(SubscriptionContext ctx) { + @Override + public void leaveFile() { + if (fileContext != null && shouldReportCollectedIssues()) { + pendingIssues.forEach(param -> fileContext.addIssue(param, MESSAGE)); + } + } + + private void resetFileState(SubscriptionContext ctx) { + pendingIssues.clear(); + fileContext = ctx; + annotatedStyleCount = 0; + oldStyleCount = 0; + } + + private void checkFunctionDef(SubscriptionContext ctx) { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); if (!hasFastAPIRouteDecorator(functionDef, ctx)) { @@ -85,9 +125,7 @@ private static void checkFunctionDef(SubscriptionContext ctx) { return; } - parameterList.nonTuple().stream() - .filter(param -> isParameterUsingOldDependencySyntax(param, ctx)) - .forEach(param -> ctx.addIssue(param, MESSAGE)); + parameterList.nonTuple().forEach(param -> collectParameterStyle(param, ctx)); } private static boolean hasFastAPIRouteDecorator(FunctionDef functionDef, SubscriptionContext ctx) { @@ -97,7 +135,36 @@ private static boolean hasFastAPIRouteDecorator(FunctionDef functionDef, Subscri .anyMatch(callExpr -> FASTAPI_ROUTE_METHODS_MATCHER.isTrueFor(callExpr.callee(), ctx)); } - private static boolean isParameterUsingOldDependencySyntax(Parameter param, SubscriptionContext ctx) { + private void collectParameterStyle(Parameter param, SubscriptionContext ctx) { + TypeAnnotation typeAnnotation = param.typeAnnotation(); + if (isUsingAnnotatedWithDependency(typeAnnotation, ctx)) { + annotatedStyleCount++; + return; + } + + if (isParameterUsingOldDependencySyntax(param, typeAnnotation, ctx)) { + oldStyleCount++; + pendingIssues.add(param); + } + } + + private boolean shouldReportCollectedIssues() { + final int minStyleSampleSize = 3; + final double oldStyleDominanceRatioThreshold = 0.75; + return switch (issueReportingMode) { + case FILE_LOCAL_HEURISTIC -> { + int totalStyleCount = oldStyleCount + annotatedStyleCount; + if (totalStyleCount < minStyleSampleSize) { + yield true; + } + double oldStyleRatio = (double) oldStyleCount / totalStyleCount; + yield oldStyleRatio < oldStyleDominanceRatioThreshold; + } + case DISABLE_FILE_LOCAL_SUPPRESSION -> true; + }; + } + + private static boolean isParameterUsingOldDependencySyntax(Parameter param, @Nullable TypeAnnotation typeAnnotation, SubscriptionContext ctx) { Expression defaultValue = param.defaultValue(); if (!(defaultValue instanceof CallExpression callExpr)) { return false; @@ -107,7 +174,6 @@ private static boolean isParameterUsingOldDependencySyntax(Parameter param, Subs return false; } - TypeAnnotation typeAnnotation = param.typeAnnotation(); return !isUsingAnnotatedWithDependency(typeAnnotation, ctx); } @@ -115,19 +181,25 @@ private static boolean isUsingAnnotatedWithDependency(@Nullable TypeAnnotation t if (typeAnnotation == null) { return false; } - Expression annotationExpr = typeAnnotation.expression(); - if (annotationExpr instanceof SubscriptionExpression subscriptionExpr) { - Expression object = subscriptionExpr.object(); - if (object instanceof Name name && TYPING_ANNOTATED_MATCHER.isTrueFor(name, ctx)) { - return subscriptionExpr.subscripts().expressions().stream() - .anyMatch(expr -> { - if (expr instanceof CallExpression callExpr) { - return FASTAPI_DEPENDENCY_FUNCTIONS_MATCHER.isTrueFor(callExpr.callee(), ctx); - } - return false; - }); - } + Expression annotationExpr = Expressions.removeParentheses(typeAnnotation.expression()); + if (!(annotationExpr instanceof SubscriptionExpression subscriptionExpr) || !isAnnotatedObject(subscriptionExpr.object(), ctx)) { + return false; + } + return subscriptionExpr.subscripts().expressions().stream() + .anyMatch(expr -> { + if (expr instanceof CallExpression callExpr) { + return FASTAPI_DEPENDENCY_FUNCTIONS_MATCHER.isTrueFor(callExpr.callee(), ctx); + } + return false; + }); + } + + private static boolean isAnnotatedObject(Expression expression, SubscriptionContext ctx) { + if (TYPING_ANNOTATED_MATCHER.isTrueFor(expression, ctx)) { + return true; } - return false; + return TreeUtils.fullyQualifiedNameFromExpression(expression) + .filter(ANNOTATED_FULLY_QUALIFIED_NAMES::contains) + .isPresent(); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/FastAPIFileUploadFormCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FastAPIFileUploadFormCheck.java index 797a74f312..61aea9cae7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FastAPIFileUploadFormCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FastAPIFileUploadFormCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FastAPIGenericRouteDecoratorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FastAPIGenericRouteDecoratorCheck.java index 52198130a9..49dadb8552 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FastAPIGenericRouteDecoratorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FastAPIGenericRouteDecoratorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FastAPIHTTPExceptionDocumentedCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FastAPIHTTPExceptionDocumentedCheck.java index 718b04c659..1e9cdf6c1f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FastAPIHTTPExceptionDocumentedCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FastAPIHTTPExceptionDocumentedCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -261,7 +261,11 @@ private static Optional extractStatusCode(Expression statusCodeExpr) { return extractStatusCode(singleAssignedValue); } } else if (statusCodeExpr instanceof NumericLiteral numericLiteral) { - return Optional.of((int) numericLiteral.valueAsLong()); + try { + return Optional.of((int) numericLiteral.valueAsLong()); + } catch (NumberFormatException e) { + return Optional.empty(); + } } else if (statusCodeExpr instanceof StringLiteral stringLiteral) { try { return Optional.of(Integer.parseInt(stringLiteral.trimmedQuotesValue())); diff --git a/python-checks/src/main/java/org/sonar/python/checks/FastAPIPathParametersCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FastAPIPathParametersCheck.java index 6dda10e40f..8fc051aa9e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FastAPIPathParametersCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FastAPIPathParametersCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -18,22 +18,36 @@ import java.util.HashSet; import java.util.List; +import java.util.Objects; import java.util.Optional; import java.util.Set; +import java.util.function.Consumer; import java.util.regex.Matcher; import java.util.regex.Pattern; +import java.util.stream.IntStream; import java.util.stream.Stream; +import javax.annotation.Nullable; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; import org.sonar.plugins.python.api.tree.Decorator; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.LambdaExpression; +import org.sonar.plugins.python.api.tree.ListLiteral; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Parameter; +import org.sonar.plugins.python.api.tree.ParameterList; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.SubscriptionExpression; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.plugins.python.api.types.v2.FunctionType; -import org.sonar.plugins.python.api.types.v2.ParameterV2; -import org.sonar.plugins.python.api.types.v2.PythonType; +import org.sonar.plugins.python.api.tree.Tuple; +import org.sonar.plugins.python.api.tree.TypeAnnotation; import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.utils.Expressions; @@ -48,7 +62,7 @@ public class FastAPIPathParametersCheck extends PythonSubscriptionCheck { private static final List HTTP_METHODS = List.of( "get", "post", "put", "delete", "patch", "options", "head", "trace"); - private static final Pattern PATH_PARAM_PATTERN = Pattern.compile("\\{([^}:]+)(?::[^}]*)?\\}"); + private static final Pattern PATH_PARAM_PATTERN = Pattern.compile("\\{([a-zA-Z_]\\w*)(?::[a-zA-Z_]\\w*)?\\}"); private static final TypeMatcher FASTAPI_ROUTE_MATCHER = TypeMatchers.any( HTTP_METHODS.stream() @@ -57,11 +71,23 @@ public class FastAPIPathParametersCheck extends PythonSubscriptionCheck { TypeMatchers.isType("fastapi.APIRouter." + method))) ); - private record FunctionParameterInfo(Set allParams, Set positionalOnlyParams, boolean hasVariadicKeyword) { - static FunctionParameterInfo empty() { - return new FunctionParameterInfo(Set.of(), Set.of(), false); - } - } + private static final TypeMatcher FASTAPI_DEPENDS_MATCHER = TypeMatchers.any( + TypeMatchers.isType("fastapi.param_functions.Depends"), + TypeMatchers.isType("fastapi.param_functions.Security")); + private static final TypeMatcher FASTAPI_PATH_MATCHER = TypeMatchers.isType("fastapi.param_functions.Path"); + private static final TypeMatcher TYPING_ANNOTATED_MATCHER = TypeMatchers.isType("typing.Annotated"); + private static final TypeMatcher FASTAPI_APPLICATION_OR_ROUTER_MATCHER = TypeMatchers.any( + TypeMatchers.isType("fastapi.FastAPI"), + TypeMatchers.isType("fastapi.applications.FastAPI"), + TypeMatchers.isType("fastapi.APIRouter"), + TypeMatchers.isType("fastapi.routing.APIRouter")); + private static final Set FASTAPI_APPLICATION_OR_ROUTER_NAMES = Set.of( + "FastAPI", + "fastapi.FastAPI", + "fastapi.applications.FastAPI", + "APIRouter", + "fastapi.APIRouter", + "fastapi.routing.APIRouter"); @Override public void initialize(Context context) { @@ -90,8 +116,410 @@ private static void checkDecorator(SubscriptionContext ctx, Decorator decorator, return; } - FunctionParameterInfo paramInfo = extractFunctionParameters(functionDef); - reportIssues(ctx, functionDef, pathParams, paramInfo); + DependencyCollector dependencyCollector = new DependencyCollector(ctx); + dependencyCollector.collect(functionDef, callExpr); + + reportIssues(ctx, functionDef, pathParams, dependencyCollector); + } + + private static final class DependencyCollector { + private final SubscriptionContext ctx; + private final Set names = new HashSet<>(); + private final Set positionalOnlyParams = new HashSet<>(); + private final Set visitedFunctions = new HashSet<>(); + // True when a dynamic, unresolved, or unsupported source could still provide route-visible parameters. + // In that case missing-parameter issues are not reliable, but positional-only issues are still reported. + private boolean hasUnresolvedOrUnsupportedParameterSources; + + DependencyCollector(SubscriptionContext ctx) { + this.ctx = ctx; + } + + void collect(FunctionDef pathOperationFunction, CallExpression pathOperationDecoratorCall) { + visitFunction(pathOperationFunction, false, true); + visitDependenciesArgument(pathOperationDecoratorCall); + visitApplicationOrRouterDependencies(pathOperationDecoratorCall); + } + + private void visitApplicationOrRouterDependencies(CallExpression pathOperationDecoratorCall) { + // FastAPI applies dependencies declared on FastAPI(...) / APIRouter(...) to every route + // registered on that object. For `router = APIRouter(dependencies=[Depends(dep)])` and + // `@router.get(...)`, inspect the receiver (`router`) as another dependency entry point. + if (!(pathOperationDecoratorCall.callee() instanceof QualifiedExpression qualifiedExpression)) { + return; + } + + Expression receiver = resolveLocalAliasChain(qualifiedExpression.qualifier()); + if (receiver instanceof CallExpression callExpression && isFastApiApplicationOrRouterCall(callExpression)) { + visitDependenciesArgument(callExpression); + } + } + + private void visitDependenciesArgument(CallExpression callExpression) { + RegularArgument dependenciesArgument = TreeUtils.argumentByKeyword("dependencies", callExpression.arguments()); + if (dependenciesArgument == null) { + return; + } + + Expression dependenciesExpression = resolveLocalAliasChain(dependenciesArgument.expression()); + if (!(dependenciesExpression instanceof ListLiteral || dependenciesExpression instanceof Tuple)) { + if (dependenciesExpression instanceof Name || dependenciesExpression instanceof QualifiedExpression) { + markUnresolvedParameterSource(); + } else { + markUnsupportedParameterSource(); + } + return; + } + + Expressions.expressionsFromListOrTuple(dependenciesExpression).forEach(this::visitDependencyListElement); + } + + private void visitDependencyListElement(Expression element) { + Expression dependency = resolveLocalAliasChain(element); + if (dependency instanceof CallExpression callExpression && isDependsCall(callExpression)) { + visitDependsCall(callExpression, null); + } else if (dependency instanceof Name || dependency instanceof QualifiedExpression) { + markUnresolvedParameterSource(); + } else { + markUnsupportedParameterSource(); + } + } + + private void visitFunction(FunctionDef functionDef, boolean skipFirstParameter, boolean recordPositionalOnlyParams) { + if (!visitedFunctions.add(functionDef)) { + return; + } + + ParameterList parameterList = functionDef.parameters(); + if (parameterList == null) { + return; + } + + visitParameterList(parameterList, skipFirstParameter, recordPositionalOnlyParams); + } + + private void visitLambda(LambdaExpression lambdaExpression) { + ParameterList parameterList = lambdaExpression.parameters(); + if (parameterList == null) { + return; + } + visitParameterList(parameterList, false, false); + } + + private void visitParameterList(ParameterList parameterList, boolean skipFirstParameter, boolean recordPositionalOnlyParams) { + List parameters = parameterList.nonTuple().stream() + .skip(skipFirstParameter ? 1 : 0) + .toList(); + + int slashParameterIndex = IntStream.range(0, parameters.size()) + .filter(i -> isSlashParameter(parameters.get(i))) + .findFirst() + .orElse(-1); + for (int i = 0; i < parameters.size(); i++) { + Parameter parameter = parameters.get(i); + if (parameter.name() != null) { + visitParameter(parameter, slashParameterIndex != -1 && i < slashParameterIndex, recordPositionalOnlyParams); + } + } + } + + private void visitParameter(Parameter parameter, boolean isPositionalOnly, boolean recordPositionalOnlyParams) { + if (parameter.starToken() != null) { + if ("**".equals(parameter.starToken().value())) { + markUnresolvedParameterSource(); + } + return; + } + + Set pathAliases = new HashSet<>(); + Expression parameterType = visitTypeAnnotation(parameter.typeAnnotation(), pathAliases::add).orElse(null); + visitDefaultValue(parameter.defaultValue(), parameterType, pathAliases::add); + + Name parameterName = parameter.name(); + if (parameterName != null) { + if (pathAliases.isEmpty()) { + names.add(parameterName.name()); + if (isPositionalOnly && recordPositionalOnlyParams) { + positionalOnlyParams.add(parameterName.name()); + } + } else { + names.addAll(pathAliases); + if (isPositionalOnly && recordPositionalOnlyParams) { + positionalOnlyParams.addAll(pathAliases); + } + } + } + } + + private Optional visitTypeAnnotation(@Nullable TypeAnnotation typeAnnotation, Consumer pathAliasConsumer) { + if (typeAnnotation == null) { + return Optional.empty(); + } + return visitTypeAnnotationExpression(typeAnnotation.expression(), new HashSet<>(), pathAliasConsumer); + } + + private Optional visitTypeAnnotationExpression(Expression annotationExpression, Set visitedAliases, Consumer pathAliasConsumer) { + // Parenthesized annotations are common in formatted multiline Annotated[...] expressions. + Expression expression = Expressions.removeParentheses(annotationExpression); + + if (expression instanceof Name name) { + Optional assignedExpression = assignedTypeAliasValue(name, visitedAliases); + if (assignedExpression.isPresent()) { + return visitTypeAnnotationExpression(assignedExpression.get(), visitedAliases, pathAliasConsumer); + } + } + + if (expression instanceof SubscriptionExpression subscriptionExpression && isAnnotatedObject(subscriptionExpression.object())) { + // Annotated stores the real type first; FastAPI metadata such as Depends and Path follows. + List subscripts = subscriptionExpression.subscripts().expressions(); + if (subscripts.isEmpty()) { + return Optional.empty(); + } + Expression baseType = subscripts.get(0); + subscripts.stream() + .skip(1) + .forEach(metadata -> visitAnnotationMetadata(metadata, baseType, pathAliasConsumer)); + return Optional.of(baseType); + } + + if (expression instanceof CallExpression) { + markUnsupportedParameterSource(); + } + + return Optional.of(expression); + } + + private void visitAnnotationMetadata(Expression metadata, @Nullable Expression parameterType, Consumer pathAliasConsumer) { + visitDependencyMarkerExpression(metadata, parameterType, pathAliasConsumer); + } + + private void visitDefaultValue(@Nullable Expression defaultValue, @Nullable Expression parameterType, Consumer pathAliasConsumer) { + if (defaultValue != null) { + visitDependencyMarkerExpression(defaultValue, parameterType, pathAliasConsumer); + } + } + + // FastAPI reads dependency/path marker objects from both parameter defaults + // and Annotated[...] metadata, so both contexts share the same handling. + private void visitDependencyMarkerExpression(Expression expression, @Nullable Expression parameterType, Consumer pathAliasConsumer) { + Expression resolvedExpression = resolveLocalAliasChain(expression); + if (resolvedExpression instanceof CallExpression callExpression) { + if (isDependsCall(callExpression)) { + visitDependsCall(callExpression, parameterType); + } else if (isPathCall(callExpression)) { + visitPathAlias(callExpression, pathAliasConsumer); + } else { + markUnsupportedParameterSource(); + } + } else if (resolvedExpression instanceof Name || resolvedExpression instanceof QualifiedExpression) { + markUnresolvedParameterSource(); + } + } + + private void visitDependsCall(CallExpression dependsCall, @Nullable Expression parameterType) { + Optional explicitTarget = TreeUtils.nthArgumentOrKeywordOptional(0, "dependency", dependsCall.arguments()) + .map(RegularArgument::expression); + Expression target = explicitTarget.orElse(parameterType); + if (target == null) { + // Bare Depends() without a parameter type gives FastAPI no callable to inspect. + return; + } + visitDependencyCallable(target); + } + + private void visitPathAlias(CallExpression pathCall, Consumer pathAliasConsumer) { + RegularArgument aliasArgument = TreeUtils.argumentByKeyword("alias", pathCall.arguments()); + if (aliasArgument == null) { + return; + } + Optional alias = extractStringValue(aliasArgument.expression()); + if (alias.isPresent()) { + pathAliasConsumer.accept(alias.get()); + } else { + markUnresolvedParameterSource(); + } + } + + private void visitDependencyCallable(Expression expression) { + // FastAPI accepts any callable dependency. We only inspect callable shapes that can be resolved locally. + Expression target = resolveLocalAliasChain(expression); + + Optional functionDef = getFunctionDef(target); + if (functionDef.isPresent()) { + // Depends(get_item) / Depends(SomeClass.get_item): FastAPI inspects the dependency function signature. + visitFunction(functionDef.get(), false, false); + return; + } + + Optional classDef = getClassDef(target); + if (classDef.isPresent()) { + // Depends(ItemQuery) / Depends() with an Annotated class type: FastAPI inspects the constructor signature. + visitClassConstructor(classDef.get()); + return; + } + + if (target instanceof CallExpression callExpression) { + // Depends(ItemChecker()) / checker = ItemChecker(); Depends(checker): FastAPI inspects the instance __call__ signature. + // FastAPI accepts arbitrary callable results from dependency factory functions, but we cannot inspect them statically. + Expression callee = resolveLocalAliasChain(callExpression.callee()); + Optional calleeClassDef = getClassDef(callee); + if (calleeClassDef.isPresent()) { + visitCallableInstance(calleeClassDef.get()); + return; + } + } + + if (target instanceof LambdaExpression lambdaExpression) { + // Depends(lambda item_id: ...): FastAPI accepts any callable, including lambdas. + visitLambda(lambdaExpression); + return; + } + + if (target instanceof Name || target instanceof QualifiedExpression) { + markUnresolvedParameterSource(); + } else { + markUnsupportedParameterSource(); + } + } + + private void visitClassConstructor(ClassDef classDef) { + Optional initFunction = topLevelMethod(classDef, "__init__"); + if (initFunction.isPresent()) { + visitFunction(initFunction.get(), true, false); + } else if (!classDef.decorators().isEmpty() || classDef.args() != null) { + // Decorators and base classes can generate or inherit constructor parameters. + markUnsupportedParameterSource(); + } + } + + private void visitCallableInstance(ClassDef classDef) { + Optional callFunction = topLevelMethod(classDef, "__call__"); + if (callFunction.isPresent()) { + visitFunction(callFunction.get(), true, false); + } else if (!classDef.decorators().isEmpty() || classDef.args() != null) { + // Decorators and base classes can generate or inherit callable behavior. + markUnsupportedParameterSource(); + } + } + + private static Expression resolveLocalAliasChain(Expression expression) { + // Follow simple local aliases like `route_deps = [Deps(...)]` while preserving the last expression when resolution stops. + Expression target = Expressions.removeParentheses(expression); + Set visitedAliases = new HashSet<>(); + while (target instanceof Name name) { + Expression assignedValue = Expressions.singleAssignedValue(name, visitedAliases); + if (assignedValue == null) { + return target; + } + target = Expressions.removeParentheses(assignedValue); + } + return target; + } + + private Optional assignedTypeAliasValue(Name name, Set visitedAliases) { + Expression assignedValue = Expressions.singleAssignedValue(name); + if (assignedValue == null) { + return Optional.empty(); + } + SymbolV2 symbol = name.symbolV2(); + if (symbol != null && !visitedAliases.add(symbol)) { + // Stop chasing type aliases such as A = B; B = A. The unresolved alias chain may hide Annotated metadata. + markUnresolvedParameterSource(); + return Optional.empty(); + } + return Optional.of(Expressions.removeParentheses(assignedValue)); + } + + private static Optional topLevelMethod(ClassDef classDef, String methodName) { + return TreeUtils.topLevelFunctionDefs(classDef).stream() + .filter(functionDef -> methodName.equals(functionDef.name().name())) + .findFirst(); + } + + private static Optional getFunctionDef(Expression expression) { + return findDeclarationAncestor(expression, UsageV2.Kind.FUNC_DECLARATION, FunctionDef.class, Tree.Kind.FUNCDEF); + } + + private static Optional getClassDef(Expression expression) { + return findDeclarationAncestor(expression, UsageV2.Kind.CLASS_DECLARATION, ClassDef.class, Tree.Kind.CLASSDEF); + } + + private static Optional findDeclarationAncestor(Expression expression, UsageV2.Kind usageKind, Class declarationClass, Tree.Kind declarationKind) { + // Map a resolved symbol usage back to the local declaration syntax node. + Name name; + if (expression instanceof Name n) { + name = n; + } else if (expression instanceof QualifiedExpression qe) { + name = qe.name(); + } else { + name = null; + } + if (name == null) { + return Optional.empty(); + } + SymbolV2 symbol = name.symbolV2(); + if (symbol == null) { + return Optional.empty(); + } + return symbol.usages().stream() + .filter(u -> u.kind() == usageKind) + .map(UsageV2::tree) + .map(tree -> TreeUtils.firstAncestorOfKind(tree, declarationKind)) + .filter(Objects::nonNull) + .map(declarationClass::cast) + .findFirst(); + } + + private boolean isAnnotatedObject(Expression expression) { + if (TYPING_ANNOTATED_MATCHER.isTrueFor(expression, ctx)) { + return true; + } + return localAliasResolvedName(expression) + .filter(name -> "Annotated".equals(name) || "typing.Annotated".equals(name) || "typing_extensions.Annotated".equals(name)) + .isPresent(); + } + + private boolean isDependsCall(CallExpression callExpression) { + return FASTAPI_DEPENDS_MATCHER.isTrueFor(callExpression.callee(), ctx) + || localAliasResolvedName(callExpression.callee()).filter(name -> "Depends".equals(name) || "Security".equals(name)).isPresent(); + } + + private boolean isPathCall(CallExpression callExpression) { + return FASTAPI_PATH_MATCHER.isTrueFor(callExpression.callee(), ctx) + || localAliasResolvedName(callExpression.callee()).filter("Path"::equals).isPresent(); + } + + private boolean isFastApiApplicationOrRouterCall(CallExpression callExpression) { + return FASTAPI_APPLICATION_OR_ROUTER_MATCHER.isTrueFor(callExpression.callee(), ctx) + || localAliasResolvedName(callExpression.callee()) + .filter(FASTAPI_APPLICATION_OR_ROUTER_NAMES::contains) + .isPresent(); + } + + private static Optional localAliasResolvedName(Expression expression) { + return TreeUtils.stringValueFromNameOrQualifiedExpression(resolveLocalAliasChain(expression)); + } + + private static boolean isSlashParameter(Parameter parameter) { + return parameter.starToken() != null && "/".equals(parameter.starToken().value()); + } + + private void markUnresolvedParameterSource() { + // Use when resolving further would likely require dynamic or intermodule data-flow analysis. + hasUnresolvedOrUnsupportedParameterSources = true; + } + + private void markUnsupportedParameterSource() { + // Use when the expression is not one of the FastAPI shapes we explicitly support. Some such + // expressions may still be valid FastAPI usage that we do not model statically yet, such as + // unpacking, calls, conditional expressions, or subscriptions producing Depends(...) or + // Path(...) values; + // others may be plainly invalid API usage and could theoretically be ignored. Proving that + // precisely is non-trivial and better left to type checking, so keep the rule conservative + // and bail out. + hasUnresolvedOrUnsupportedParameterSources = true; + } + } private static Set extractPathParameters(CallExpression callExpr) { @@ -114,54 +542,18 @@ private static Optional extractStringValue(Expression expression) { .map(Expressions::unescape); } - private static FunctionParameterInfo extractFunctionParameters(FunctionDef functionDef) { - return getFunctionType(functionDef) - .map(FastAPIPathParametersCheck::buildParameterInfo) - .orElse(FunctionParameterInfo.empty()); - } - - private static Optional getFunctionType(FunctionDef functionDef) { - PythonType functionType = functionDef.name().typeV2(); - if (functionType instanceof FunctionType funcType) { - return Optional.of(funcType); - } - return Optional.empty(); - } - - private static FunctionParameterInfo buildParameterInfo(FunctionType functionType) { - Set allParams = new HashSet<>(); - Set positionalOnlyParams = new HashSet<>(); - boolean hasVariadicKeyword = functionType.parameters().stream() - .anyMatch(param -> param.isVariadic() && param.isKeywordVariadic()); - - functionType.parameters().stream() - .filter(param -> !param.isVariadic()) - .forEach(param -> addParameter(param, allParams, positionalOnlyParams)); - - return new FunctionParameterInfo(allParams, positionalOnlyParams, hasVariadicKeyword); - } - - private static void addParameter(ParameterV2 param, Set allParams, Set positionalOnlyParams) { - String paramName = param.name(); - if (paramName != null) { - allParams.add(paramName); - if (param.isPositionalOnly()) { - positionalOnlyParams.add(paramName); - } - } - } - - private static void reportIssues(SubscriptionContext ctx, FunctionDef functionDef, Set pathParams, FunctionParameterInfo paramInfo) { + private static void reportIssues( + SubscriptionContext ctx, + FunctionDef functionDef, + Set pathParams, + DependencyCollector dependencyCollector) { pathParams.stream() - .filter(param -> isMissingFromSignature(param, paramInfo)) + .filter(param -> !dependencyCollector.names.contains(param)) + .filter(param -> !dependencyCollector.hasUnresolvedOrUnsupportedParameterSources) .forEach(param -> ctx.addIssue(functionDef.name(), String.format(MISSING_PARAM_MESSAGE, param))); pathParams.stream() - .filter(paramInfo.positionalOnlyParams::contains) + .filter(dependencyCollector.positionalOnlyParams::contains) .forEach(param -> ctx.addIssue(functionDef.name(), String.format(POSITIONAL_ONLY_MESSAGE, param))); } - - private static boolean isMissingFromSignature(String pathParam, FunctionParameterInfo paramInfo) { - return !paramInfo.allParams.contains(pathParam) && !paramInfo.hasVariadicKeyword; - } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/FastAPIRedundantResponseModelCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FastAPIRedundantResponseModelCheck.java index a18b2305ce..264d82c4e4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FastAPIRedundantResponseModelCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FastAPIRedundantResponseModelCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FastApiImportStringCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FastApiImportStringCheck.java index ab3858e626..521207e9b1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FastApiImportStringCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FastApiImportStringCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FieldDuplicatesClassNameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FieldDuplicatesClassNameCheck.java index 6e264b317c..91a1816f56 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FieldDuplicatesClassNameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FieldDuplicatesClassNameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FieldNameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FieldNameCheck.java index 151cf73050..119138d0da 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FieldNameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FieldNameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FileComplexityCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FileComplexityCheck.java index 2fa51e2d13..4921c09a59 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FileComplexityCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FileComplexityCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FileHeaderCopyrightCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FileHeaderCopyrightCheck.java index c585c5d745..419fa62fef 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FileHeaderCopyrightCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FileHeaderCopyrightCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FilePermissionsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FilePermissionsCheck.java index e79b2e7464..3bf0d93d34 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FilePermissionsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FilePermissionsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -99,7 +99,11 @@ private static boolean isUnsafeExpression(Expression expression, int safeModulo, } if (expression.is(Tree.Kind.NUMERIC_LITERAL)) { NumericLiteral numericLiteral = (NumericLiteral) expression; - return numericLiteral.valueAsLong() % 8 != safeModulo; + try { + return numericLiteral.valueAsLong() % 8 != safeModulo; + } catch (NumberFormatException nfe) { + return false; + } } if (expression.is(Tree.Kind.NAME)) { Expression singleAssignedValue = Expressions.singleAssignedValue(((Name) expression)); diff --git a/python-checks/src/main/java/org/sonar/python/checks/FixmeCommentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FixmeCommentCheck.java index 0bf4f13df7..23035be23f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FixmeCommentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FixmeCommentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskErrorHandlerStatusCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskErrorHandlerStatusCheck.java index c74b1e64ff..0af449eb98 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskErrorHandlerStatusCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskErrorHandlerStatusCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedJWTSecretKeyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedJWTSecretKeyCheck.java index f7a0b90f23..34015ff5d6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedJWTSecretKeyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedJWTSecretKeyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedSecret.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedSecret.java index 99bb75615a..d70fffc7cf 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedSecret.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedSecret.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -38,6 +38,7 @@ import org.sonar.plugins.python.api.tree.Tree; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; +import org.sonarsource.analyzer.commons.appsec.SecretClassifier; public abstract class FlaskHardCodedSecret extends PythonSubscriptionCheck { @@ -133,20 +134,20 @@ private boolean isIllegalKeyValuePair(KeyValuePair keyValuePair) { .map(StringLiteral.class::cast) .map(StringLiteral::trimmedQuotesValue) .filter(getSecretKeyKeyword()::equals) - .isPresent() && isStringValue(keyValuePair.value()); + .isPresent() && isPotentialSecretValue(keyValuePair.value()); } private Optional getIllegalKeywordArgument(CallExpression callExpression) { return Optional.ofNullable(TreeUtils.argumentByKeyword(getSecretKeyKeyword(), callExpression.arguments())) .filter(argument -> Optional.of(argument) .map(RegularArgument::expression) - .filter(FlaskHardCodedSecret::isStringValue) + .filter(FlaskHardCodedSecret::isPotentialSecretValue) .isPresent()); } private void verifyAssignmentStatement(SubscriptionContext ctx) { AssignmentStatement assignmentStatementTree = (AssignmentStatement) ctx.syntaxNode(); - if (!isStringValue(assignmentStatementTree.assignedValue())) { + if (!isPotentialSecretValue(assignmentStatementTree.assignedValue())) { return; } List expressionList = assignmentStatementTree.lhsExpressions().stream() @@ -181,24 +182,27 @@ protected boolean isSensitiveProperty(Expression expression) { .isPresent(); } - private static boolean isStringValue(@Nullable Expression expr) { - return isStringValue(expr, new HashSet<>()); + // True when expr resolves to a string literal that SecretClassifier does NOT recognize as a known non-secret placeholder. + private static boolean isPotentialSecretValue(@Nullable Expression expr) { + return resolveStringValue(expr, new HashSet<>()) + .filter(value -> !SecretClassifier.isKnownNonSecret(value)) + .isPresent(); } - - private static boolean isStringValue(@Nullable Expression expr, Set visited) { + private static Optional resolveStringValue(@Nullable Expression expr, Set visited) { if (expr == null) { - return false; + return Optional.empty(); } if (expr.is(Tree.Kind.NAME)) { if (visited.contains(((Name) expr).name())) { - return false; + return Optional.empty(); } visited.add(((Name) expr).name()); Expression assignmentValueExpression = Expressions.singleAssignedValue((Name) expr); - return isStringValue(assignmentValueExpression, visited); - } else { - return expr.is(Tree.Kind.STRING_LITERAL); + return resolveStringValue(assignmentValueExpression, visited); + } else if (expr.is(Tree.Kind.STRING_LITERAL)) { + return Optional.of(((StringLiteral) expr).trimmedQuotesValue()); } + return Optional.empty(); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedSecretKeyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedSecretKeyCheck.java index 9d85c2cc4f..cfefc2084f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedSecretKeyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskHardCodedSecretKeyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskHeadersDictAccessCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskHeadersDictAccessCheck.java index 2eafe15541..e8cad03c89 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskHeadersDictAccessCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskHeadersDictAccessCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskPostWithQueryParameterCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskPostWithQueryParameterCheck.java index 59d817257f..c2769c6335 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskPostWithQueryParameterCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskPostWithQueryParameterCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskPreprocessRequestCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskPreprocessRequestCheck.java index b229647765..4d6c83dc7e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskPreprocessRequestCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskPreprocessRequestCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskRouteMethodsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskRouteMethodsCheck.java index 39d35088fd..1f63affec5 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskRouteMethodsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskRouteMethodsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -24,7 +24,6 @@ import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.FunctionDef; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.plugins.python.api.tree.UnpackingExpression; import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.tree.TreeUtils; @@ -74,9 +73,6 @@ private static boolean hasMethodsParameter(CallExpression callExpr) { return true; } - return callExpr.arguments().stream() - .filter(UnpackingExpression.class::isInstance) - .map(UnpackingExpression.class::cast) - .anyMatch(unpacking -> "**".equals(unpacking.starToken().value())); + return callExpr.arguments().stream().anyMatch(TreeUtils::isDoubleStarExpression); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskSendFileMimeTypeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskSendFileMimeTypeCheck.java index e77b67d670..a463f1f3ed 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskSendFileMimeTypeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskSendFileMimeTypeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FlaskViewDecoratorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FlaskViewDecoratorCheck.java index e49deacc24..723c72cdd1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FlaskViewDecoratorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FlaskViewDecoratorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FloatingPointEqualityCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FloatingPointEqualityCheck.java index 9641caa28a..01f60f8d11 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FloatingPointEqualityCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FloatingPointEqualityCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -32,7 +32,6 @@ import org.sonar.plugins.python.api.tree.ImportName; import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.cfg.fixpoint.ReachingDefinitionsAnalysis; import org.sonar.python.quickfix.TextEditUtils; import org.sonar.python.tree.TreeUtils; import org.sonar.python.types.v2.TypeChecker; @@ -52,7 +51,6 @@ public class FloatingPointEqualityCheck extends PythonSubscriptionCheck { private static final String MATH_MODULE = "math"; - private ReachingDefinitionsAnalysis reachingDefinitionsAnalysis; private static final List SUPPORTED_IS_CLOSE_MODULES = Arrays.asList("numpy", "torch", MATH_MODULE); private String importedModuleForIsClose; @@ -71,7 +69,6 @@ public void initialize(Context context) { } private void initializeAnalysis(SubscriptionContext ctx) { - reachingDefinitionsAnalysis = new ReachingDefinitionsAnalysis(ctx.pythonFile()); importedModuleForIsClose = null; importedAlias = null; typeChecker = ctx.typeChecker(); @@ -80,19 +77,19 @@ private void initializeAnalysis(SubscriptionContext ctx) { private void checkFloatingPointEquality(SubscriptionContext ctx) { BinaryExpression binaryExpression = (BinaryExpression) ctx.syntaxNode(); String operator = binaryExpression.operator().value(); - if (("==".equals(operator) || "!=".equals(operator)) && isAnyOperandFloatingPoint(binaryExpression)) { + if (("==".equals(operator) || "!=".equals(operator)) && isAnyOperandFloatingPoint(binaryExpression, ctx)) { PreciseIssue issue = ctx.addIssue(binaryExpression, MESSAGE); issue.addQuickFix(createQuickFix(binaryExpression, operator)); } } - private boolean isAnyOperandFloatingPoint(BinaryExpression binaryExpression) { + private boolean isAnyOperandFloatingPoint(BinaryExpression binaryExpression, SubscriptionContext ctx) { Expression leftOperand = binaryExpression.leftOperand(); Expression rightOperand = binaryExpression.rightOperand(); return isFloat(leftOperand) || isFloat(rightOperand) || - isAssignedFloat(leftOperand) || isAssignedFloat(rightOperand) || - isBinaryOperationWithFloat(leftOperand) || isBinaryOperationWithFloat(rightOperand); + isAssignedFloat(leftOperand, ctx) || isAssignedFloat(rightOperand, ctx) || + isBinaryOperationWithFloat(leftOperand, ctx) || isBinaryOperationWithFloat(rightOperand, ctx); } private boolean isFloat(Expression expression) { @@ -100,9 +97,9 @@ private boolean isFloat(Expression expression) { return expression.is(Tree.Kind.NUMERIC_LITERAL) && isTypeFloat == TriBool.TRUE; } - private boolean isAssignedFloat(Expression expression) { + private boolean isAssignedFloat(Expression expression, SubscriptionContext ctx) { if (expression.is(Tree.Kind.NAME)) { - Set values = reachingDefinitionsAnalysis.valuesAtLocation((Name) expression); + Set values = ctx.valuesAtLocation((Name) expression); if (!values.isEmpty()) { return values.stream().allMatch(this::isFloat); } @@ -110,9 +107,9 @@ private boolean isAssignedFloat(Expression expression) { return false; } - private boolean isBinaryOperationWithFloat(Expression expression) { + private boolean isBinaryOperationWithFloat(Expression expression, SubscriptionContext ctx) { if (expression.is(BINARY_OPERATION_KINDS)) { - return isAnyOperandFloatingPoint((BinaryExpression) expression); + return isAnyOperandFloatingPoint((BinaryExpression) expression, ctx); } return false; } diff --git a/python-checks/src/main/java/org/sonar/python/checks/FunctionComplexityCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FunctionComplexityCheck.java index dac8b775b4..7041724b76 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FunctionComplexityCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FunctionComplexityCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FunctionNameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FunctionNameCheck.java index ce6f370303..c37c98f0b5 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FunctionNameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FunctionNameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FunctionReturnTypeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FunctionReturnTypeCheck.java index 3a8af277d4..3410cfdd16 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FunctionReturnTypeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FunctionReturnTypeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/FunctionUsingLoopVariableCheck.java b/python-checks/src/main/java/org/sonar/python/checks/FunctionUsingLoopVariableCheck.java index c6991f8418..c1593147c1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/FunctionUsingLoopVariableCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/FunctionUsingLoopVariableCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/GenericClassTypeParameterCheck.java b/python-checks/src/main/java/org/sonar/python/checks/GenericClassTypeParameterCheck.java index 70da79648b..cb5bb03caf 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/GenericClassTypeParameterCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/GenericClassTypeParameterCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/GenericExceptionRaisedCheck.java b/python-checks/src/main/java/org/sonar/python/checks/GenericExceptionRaisedCheck.java index f206a835e2..a35ec6133b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/GenericExceptionRaisedCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/GenericExceptionRaisedCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -19,11 +19,20 @@ import java.util.List; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; -import org.sonar.plugins.python.api.TriBool; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.RaiseStatement; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.Tree.Kind; -import org.sonar.plugins.python.api.types.v2.PythonType; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; import static org.sonar.plugins.python.api.types.BuiltinTypes.BASE_EXCEPTION; import static org.sonar.plugins.python.api.types.BuiltinTypes.EXCEPTION; @@ -31,21 +40,72 @@ @Rule(key = "S112") public class GenericExceptionRaisedCheck extends PythonSubscriptionCheck { + private static final String MESSAGE = "Replace this generic exception class with a more specific one."; + + private final TypeMatcher isExceptionOrBaseExceptionMatcher = TypeMatchers.any( + TypeMatchers.isObjectOfType(EXCEPTION), + TypeMatchers.isObjectOfType(BASE_EXCEPTION), + TypeMatchers.isType(EXCEPTION), + TypeMatchers.isType(BASE_EXCEPTION) + ); + + private final TypeMatcher isObjectOfTypeExceptionOrBaseExceptionMatcher = TypeMatchers.any( + TypeMatchers.isObjectOfType(EXCEPTION), + TypeMatchers.isObjectOfType(BASE_EXCEPTION) + ); + @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Kind.RAISE_STMT, ctx -> { - RaiseStatement raise = (RaiseStatement) ctx.syntaxNode(); - List expressions = raise.expressions(); - if (expressions.isEmpty()) { - return; + context.registerSyntaxNodeConsumer(Kind.RAISE_STMT, this::checkRaise); + context.registerSyntaxNodeConsumer(Kind.CALL_EXPR, this::checkFunctionCall); + } + + private void checkRaise(SubscriptionContext ctx) { + RaiseStatement raise = (RaiseStatement) ctx.syntaxNode(); + List expressions = raise.expressions(); + if (expressions.isEmpty()) { + return; + } + + Expression expression = expressions.get(0); + if (!isExceptionOrBaseExceptionMatcher.isTrueFor(expression, ctx)) { + return; + } + if (!isExceptionFunctionLocal(expression, raise)) { + return; + } + ctx.addIssue(expression, MESSAGE); + } + + private void checkFunctionCall(SubscriptionContext ctx) { + CallExpression call = (CallExpression) ctx.syntaxNode(); + List arguments = call.arguments(); + for (Argument arg : arguments) { + if (!(arg instanceof RegularArgument regArg) || regArg.keywordArgument() != null) { + continue; } - Expression expression = expressions.get(0); - PythonType pythonType = expression.typeV2(); - TriBool isException = ctx.typeChecker().typeCheckBuilder().isBuiltinWithName(EXCEPTION).check(pythonType); - TriBool isBaseException = ctx.typeChecker().typeCheckBuilder().isBuiltinWithName(BASE_EXCEPTION).check(pythonType); - if (isException == TriBool.TRUE || isBaseException == TriBool.TRUE) { - ctx.addIssue(expression, "Replace this generic exception class with a more specific one."); + Expression argExpr = regArg.expression(); + if (isObjectOfTypeExceptionOrBaseExceptionMatcher.isTrueFor(argExpr, ctx) && isExceptionFunctionLocal(argExpr, call)) { + ctx.addIssue(argExpr, MESSAGE); } - }); + } + } + + private static boolean isExceptionFunctionLocal(Expression expression, Tree contextTree) { + if (!(expression instanceof Name name)) return true; + SymbolV2 symbolV2 = name.symbolV2(); + return symbolV2 == null || isLocalVariable(symbolV2, contextTree); + } + + private static boolean isLocalVariable(SymbolV2 symbol, Tree contextTree) { + Tree function = TreeUtils.firstAncestorOfKind(contextTree, Kind.FUNCDEF); + if (function == null) { + return false; + } + + return symbol.getSingleBindingUsage() + .filter(u -> !u.kind().equals(UsageV2.Kind.PARAMETER)) + .map(usage -> TreeUtils.firstAncestor(usage.tree(), t -> t == function) != null) + .orElse(false); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/GenericFunctionTypeParameterCheck.java b/python-checks/src/main/java/org/sonar/python/checks/GenericFunctionTypeParameterCheck.java index 8bb0a24e6e..617e6f06e8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/GenericFunctionTypeParameterCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/GenericFunctionTypeParameterCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/GenericTypeStatementCheck.java b/python-checks/src/main/java/org/sonar/python/checks/GenericTypeStatementCheck.java index a434a3a48f..4582965299 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/GenericTypeStatementCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/GenericTypeStatementCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheck.java index a3177033dd..eba3c13fb7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/GraphQLDenialOfServiceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/GraphQLDenialOfServiceCheck.java index c40a31559a..0fa3c2f66c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/GraphQLDenialOfServiceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/GraphQLDenialOfServiceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -93,8 +93,8 @@ private static boolean hasSafeMiddlewares(List arguments) { } Optional argumentValue = Expressions.ifNameGetSingleAssignedNonNameValue(argument.expression()); - boolean isNotTupleNorListLiteral = argumentValue.filter(a -> a.is(Tree.Kind.LIST_LITERAL, Tree.Kind.TUPLE)).isEmpty(); - return isNotTupleNorListLiteral || Expressions.expressionsFromListOrTuple(argumentValue.get()).stream().anyMatch(GraphQLDenialOfServiceCheck::isSafeMiddlewareName); + boolean isNotCollectionLiteral = argumentValue.filter(a -> a.is(Tree.Kind.LIST_LITERAL, Tree.Kind.TUPLE, Tree.Kind.SET_LITERAL)).isEmpty(); + return isNotCollectionLiteral || Expressions.expressionsFromListOrTuple(argumentValue.get()).stream().anyMatch(GraphQLDenialOfServiceCheck::isSafeMiddlewareName); } private static boolean hasSafeValidationRules(List arguments) { @@ -104,8 +104,8 @@ private static boolean hasSafeValidationRules(List arguments) { } Optional argumentValue = Expressions.ifNameGetSingleAssignedNonNameValue(argument.expression()); - boolean isNotTupleNorListLiteral = argumentValue.filter(a -> a.is(Tree.Kind.LIST_LITERAL, Tree.Kind.TUPLE)).isEmpty(); - return isNotTupleNorListLiteral || Expressions.expressionsFromListOrTuple(argumentValue.get()).stream().anyMatch(GraphQLDenialOfServiceCheck::isSafeValidationRule); + boolean isNotCollectionLiteral = argumentValue.filter(a -> a.is(Tree.Kind.LIST_LITERAL, Tree.Kind.TUPLE, Tree.Kind.SET_LITERAL)).isEmpty(); + return isNotCollectionLiteral || Expressions.expressionsFromListOrTuple(argumentValue.get()).stream().anyMatch(GraphQLDenialOfServiceCheck::isSafeValidationRule); } private static boolean isSafeValidationRule(Expression value) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/GroupByIteratorReuseCheck.java b/python-checks/src/main/java/org/sonar/python/checks/GroupByIteratorReuseCheck.java new file mode 100644 index 0000000000..078897d304 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/GroupByIteratorReuseCheck.java @@ -0,0 +1,213 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.List; +import java.util.Optional; +import java.util.Set; +import java.util.function.Predicate; +import java.util.stream.Stream; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.ArgList; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ForStatement; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.YieldExpression; +import org.sonar.plugins.python.api.tree.YieldStatement; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8516") +public class GroupByIteratorReuseCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Consume this group iterator inside the loop, or materialize it into a collection."; + private static final String QUICK_FIX_MESSAGE = "Wrap with \"list()\""; + + private static final TypeMatcher GROUPBY_MATCHER = TypeMatchers.isType("itertools.groupby"); + + private static final TypeMatcher SAFE_CONSUMER_MATCHER = TypeMatchers.any( + TypeMatchers.isType("list"), + TypeMatchers.isType("tuple"), + TypeMatchers.isType("set"), + TypeMatchers.isType("frozenset"), + TypeMatchers.isType("sorted"), + TypeMatchers.isType("sum"), + TypeMatchers.isType("max"), + TypeMatchers.isType("min"), + TypeMatchers.isType("any"), + TypeMatchers.isType("all"), + TypeMatchers.isType("next"), + TypeMatchers.isType("len"), + TypeMatchers.isType("str.join"), + TypeMatchers.isType("bytes.join") + ); + + // Matches class objects produced at runtime via `type(...)` (e.g. `Cls = type(obj); Cls(group)`). + // Direct class references (`MyClass`) are NOT matched here + private static final TypeMatcher RUNTIME_CLASS_OBJECT_MATCHER = TypeMatchers.isObjectOfType("type"); + + // Container methods that store their argument *as a single element* without iterating it. + private static final Set STORING_METHOD_NAMES = Set.of( + "append", "add", "setdefault" + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FOR_STMT, GroupByIteratorReuseCheck::checkForStatement); + } + + private static void checkForStatement(SubscriptionContext ctx) { + ForStatement forStatement = (ForStatement) ctx.syntaxNode(); + Name groupName = extractGroupByLoopVariable(forStatement, ctx).orElse(null); + if (groupName == null) { + return; + } + SymbolV2 groupSymbol = groupName.symbolV2(); + if (groupSymbol == null) { + return; + } + + Tree loopBody = forStatement.body(); + + // Bail on any rebinding of `group` in the body to avoid requiring a CFG + boolean isReboundInLoopBody = namesInLoopBody(groupSymbol, loopBody, + usage -> usage.kind() == UsageV2.Kind.ASSIGNMENT_LHS).findAny().isPresent(); + if (isReboundInLoopBody) { + return; + } + + List loopBodyReads = namesInLoopBody(groupSymbol, loopBody, + usage -> !usage.isBindingUsage()).toList(); + + List unsafeReads = loopBodyReads.stream() + .filter(nameUsage -> isUnsafeRead(nameUsage, forStatement, ctx)) + .toList(); + + // Quickfix only when there is a single read in the body: wrapping `group` in `list()` + // consumes the iterator and would silently break any other read. + boolean canOfferQuickFix = loopBodyReads.size() == 1 && unsafeReads.size() == 1; + for (Name nameUsage : unsafeReads) { + var issue = ctx.addIssue(nameUsage, MESSAGE); + if (canOfferQuickFix) { + PythonQuickFix quickFix = PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.insertBefore(nameUsage, "list(")) + .addTextEdit(TextEditUtils.insertAfter(nameUsage, ")")) + .build(); + issue.addQuickFix(quickFix); + } + } + } + + // Matches `for key, group in groupby(...):` and returns the `group` name + private static Optional extractGroupByLoopVariable(ForStatement forStatement, SubscriptionContext ctx) { + if (forStatement.testExpressions().size() != 1 + || !(forStatement.testExpressions().get(0) instanceof CallExpression callExpr) + || !GROUPBY_MATCHER.isTrueFor(callExpr.callee(), ctx) + || forStatement.expressions().size() != 2 + || !(forStatement.expressions().get(1) instanceof Name groupName)) { + return Optional.empty(); + } + return Optional.of(groupName); + } + + // Recognized escape sinks: lambda/nested-function capture, assignment rvalue, yield, and + // positional argument of a known storing-method. Anything else is treated as safe. + private static boolean isUnsafeRead(Name nameUsage, ForStatement enclosingForStatement, SubscriptionContext ctx) { + if (isCapturedByNestedFunctionOrLambda(nameUsage, enclosingForStatement)) { + return true; + } + return reachesSink(nameUsage, ctx); + } + + private static boolean reachesSink(Expression expression, SubscriptionContext ctx) { + Tree parent = expression.parent(); + if (parent instanceof AssignmentStatement assign && assign.assignedValue() == expression) { + return true; + } + if (parent instanceof YieldExpression || parent instanceof YieldStatement) { + return true; + } + // Keyword arguments are skipped (treated as safe): mapping them to the callee's parameter would + // require signature resolution, and iterators are overwhelmingly passed positionally in practice. + if (parent instanceof RegularArgument regularArg && regularArg.keywordArgument() == null) { + return chainReachesSink(regularArg, ctx); + } + return false; + } + + private static boolean chainReachesSink(RegularArgument arg, SubscriptionContext ctx) { + CallExpression call = owningCall(arg).orElse(null); + if (call == null) { + return false; + } + if (isSafeConsumerCallee(call.callee(), ctx)) { + return false; + } + if (isStoringMethodCall(call)) { + return true; + } + return reachesSink(call, ctx); + } + + private static boolean isSafeConsumerCallee(Expression callee, SubscriptionContext ctx) { + return !SAFE_CONSUMER_MATCHER.evaluateFor(callee, ctx).isFalse() + || !RUNTIME_CLASS_OBJECT_MATCHER.evaluateFor(callee, ctx).isFalse(); + } + + // Name-only on purpose: gating on the receiver type would silently miss the case where the + // receiver's type cannot be resolved. Middle ground between FP risk and raising actual issues. + private static boolean isStoringMethodCall(CallExpression call) { + return call.callee() instanceof QualifiedExpression qualified + && STORING_METHOD_NAMES.contains(qualified.name().name()); + } + + private static boolean isCapturedByNestedFunctionOrLambda(Name nameUsage, ForStatement enclosingForStatement) { + Tree functionLikeAncestor = TreeUtils.firstAncestorOfKind(nameUsage, Tree.Kind.FUNCDEF, Tree.Kind.LAMBDA); + return functionLikeAncestor != null && isInside(functionLikeAncestor, enclosingForStatement.body()); + } + + private static Stream namesInLoopBody(SymbolV2 symbol, Tree loopBody, Predicate usageFilter) { + return symbol.usages().stream() + .filter(usageFilter) + .map(UsageV2::tree) + .flatMap(TreeUtils.toStreamInstanceOfMapper(Name.class)) + .filter(name -> isInside(name, loopBody)); + } + + private static boolean isInside(Tree tree, Tree container) { + return TreeUtils.firstAncestor(tree, ancestor -> ancestor == container) != null; + } + + private static Optional owningCall(RegularArgument regularArg) { + if (regularArg.parent() instanceof ArgList argList && argList.parent() instanceof CallExpression callExpr) { + return Optional.of(callExpr); + } + return Optional.empty(); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/HardcodedCredentialsCallCheck.java b/python-checks/src/main/java/org/sonar/python/checks/HardcodedCredentialsCallCheck.java index 960417fac8..3613567160 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/HardcodedCredentialsCallCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/HardcodedCredentialsCallCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -44,6 +44,7 @@ import org.sonar.plugins.python.api.tree.Tree; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; +import org.sonarsource.analyzer.commons.appsec.SecretClassifier; @Rule(key = "S6437") public class HardcodedCredentialsCallCheck extends PythonSubscriptionCheck { @@ -91,6 +92,7 @@ private static void checkArgument(SubscriptionContext ctx, RegularArgument argum .map(StringLiteral.class::cast) .filter(Predicate.not(HardcodedCredentialsCallCheck::containsFormattedExpressions)) .filter(HardcodedCredentialsCallCheck::isNotEmpty) + .filter(HardcodedCredentialsCallCheck::isNotKnownNonSecret) .ifPresent(string -> ctx.addIssue(argument, MESSAGE)); } else if (argExp.is(Tree.Kind.NAME)) { findAssignment((Name) argExp, 0) @@ -98,6 +100,7 @@ private static void checkArgument(SubscriptionContext ctx, RegularArgument argum .map(StringLiteral.class::cast) .filter(Predicate.not(HardcodedCredentialsCallCheck::containsFormattedExpressions)) .filter(HardcodedCredentialsCallCheck::isNotEmpty) + .filter(HardcodedCredentialsCallCheck::isNotKnownNonSecret) .ifPresent(assignedValue -> ctx.addIssue(argument, MESSAGE).secondary(assignedValue, MESSAGE)); } } @@ -106,7 +109,11 @@ private static boolean isNotEmpty(StringLiteral stringLiteral) { return Optional.of(stringLiteral) .map(StringLiteral::trimmedQuotesValue) .filter(Predicate.not(String::isEmpty)) - .isPresent(); + .isPresent(); + } + + private static boolean isNotKnownNonSecret(StringLiteral stringLiteral) { + return !SecretClassifier.isKnownNonSecret(stringLiteral.trimmedQuotesValue()); } private static boolean containsFormattedExpressions(StringLiteral stringLiteral) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/HardcodedIPCheck.java b/python-checks/src/main/java/org/sonar/python/checks/HardcodedIPCheck.java index 643f055eb9..375948c578 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/HardcodedIPCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/HardcodedIPCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -23,6 +23,12 @@ import javax.annotation.Nullable; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.ParenthesizedExpression; import org.sonar.plugins.python.api.tree.StringLiteral; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.python.checks.utils.Expressions; @@ -62,8 +68,11 @@ public class HardcodedIPCheck extends PythonSubscriptionCheck { @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.STRING_LITERAL, ctx -> { + if (ctx.isLikelyTestFile()) { + return; + } StringLiteral stringLiteral = (StringLiteral) ctx.syntaxNode(); - if (isMultilineString(stringLiteral)) { + if (isMultilineString(stringLiteral) || isVersionLiteral(stringLiteral)) { return; } String content = Expressions.unescape(stringLiteral); @@ -88,6 +97,32 @@ public void initialize(Context context) { }); } + private static boolean isVersionLiteral(StringLiteral stringLiteral) { + Expression assignedValue = stringLiteral; + while (assignedValue.parent() instanceof ParenthesizedExpression parenthesizedExpression) { + assignedValue = parenthesizedExpression; + } + Tree parent = assignedValue.parent(); + if (parent instanceof AssignmentStatement assignment) { + return assignment.assignedValue() == assignedValue && hasVersionName(assignment); + } + return parent instanceof AnnotatedAssignment assignment + && assignment.assignedValue() == assignedValue + && isVersionName(assignment.variable()); + } + + private static boolean hasVersionName(AssignmentStatement assignment) { + if (assignment.lhsExpressions().size() != 1) { + return false; + } + ExpressionList lhsExpressions = assignment.lhsExpressions().get(0); + return lhsExpressions.expressions().size() == 1 && isVersionName(lhsExpressions.expressions().get(0)); + } + + private static boolean isVersionName(Expression expression) { + return Expressions.removeParentheses(expression) instanceof Name name && "__version__".equals(name.name()); + } + private static boolean isMultilineString(StringLiteral pyStringLiteralTree) { return pyStringLiteralTree.stringElements().size() > 1; } diff --git a/python-checks/src/main/java/org/sonar/python/checks/HashMethodCheck.java b/python-checks/src/main/java/org/sonar/python/checks/HashMethodCheck.java index 647bd4e2d7..da4a1aa05c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/HashMethodCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/HashMethodCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/HttpNoContentNonEmptyBodyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/HttpNoContentNonEmptyBodyCheck.java index 4cf7486494..f25a6522ff 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/HttpNoContentNonEmptyBodyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/HttpNoContentNonEmptyBodyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -32,7 +32,6 @@ import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; -import org.sonar.python.cfg.fixpoint.ReachingDefinitionsAnalysis; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; @@ -41,8 +40,6 @@ public class HttpNoContentNonEmptyBodyCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Return an empty body for this endpoint returning 204 status."; - private ReachingDefinitionsAnalysis reachingDefinitionsAnalysis; - private static final TypeMatcher FASTAPI_RESPONSE_INSTANCE = TypeMatchers.isObjectOfType("fastapi.Response"); private static final TypeMatcher NONE_TYPE = TypeMatchers.isObjectOfType("NoneType"); @@ -54,18 +51,14 @@ public class HttpNoContentNonEmptyBodyCheck extends PythonSubscriptionCheck { TypeMatchers.withFQN("fastapi.applications.FastAPI.patch"), TypeMatchers.withFQN("fastapi.applications.FastAPI.options"), TypeMatchers.withFQN("fastapi.applications.FastAPI.head"), - TypeMatchers.withFQN("fastapi.applications.FastAPI.trace") - ); + TypeMatchers.withFQN("fastapi.applications.FastAPI.trace")); @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> - reachingDefinitionsAnalysis = new ReachingDefinitionsAnalysis(ctx.pythonFile()) - ); - context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, this::checkFunctionDef); + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, HttpNoContentNonEmptyBodyCheck::checkFunctionDef); } - private void checkFunctionDef(SubscriptionContext ctx) { + private static void checkFunctionDef(SubscriptionContext ctx) { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); if (!isFastApiEndpointWithNoContentStatus(ctx, functionDef)) { @@ -79,9 +72,7 @@ private static boolean isFastApiEndpointWithNoContentStatus(SubscriptionContext for (Decorator decorator : functionDef.decorators()) { Expression decoratorExpression = decorator.expression(); - if (decoratorExpression.is(Tree.Kind.CALL_EXPR)) { - CallExpression callExpr = (CallExpression) decoratorExpression; - + if (decoratorExpression instanceof CallExpression callExpr) { if (!FASTAPI_METHODS_MATCHER.isTrueFor(callExpr.callee(), ctx)) { continue; } @@ -106,7 +97,7 @@ private static boolean isNoContentStatusValue(Expression expr) { return false; } - private void findProblematicReturns(SubscriptionContext ctx, FunctionDef functionDef) { + private static void findProblematicReturns(SubscriptionContext ctx, FunctionDef functionDef) { List allReturns = new ArrayList<>(); collectReturnStatements(functionDef.body(), allReturns); @@ -141,7 +132,7 @@ private static void collectReturnStatements(Tree tree, List ret tree.children().forEach(child -> collectReturnStatements(child, returns)); } - private ValidationResult isValidReturnStatement(SubscriptionContext ctx, ReturnStatement returnStmt) { + private static ValidationResult isValidReturnStatement(SubscriptionContext ctx, ReturnStatement returnStmt) { List expressions = returnStmt.expressions(); if (expressions.isEmpty()) { @@ -167,39 +158,31 @@ private ValidationResult isValidReturnStatement(SubscriptionContext ctx, ReturnS return new ValidationResult(false); } - private ValidationResult isValidResponseObject(SubscriptionContext ctx, Expression expr) { + private static ValidationResult isValidResponseObject(SubscriptionContext ctx, Expression expr) { if (!FASTAPI_RESPONSE_INSTANCE.isTrueFor(expr, ctx)) { return new ValidationResult(false); } List secondaryLocations = new ArrayList<>(); - if (expr.is(Tree.Kind.NAME)) { - Name name = (Name) expr; - var assignedValues = reachingDefinitionsAnalysis.valuesAtLocation(name); + if (expr instanceof Name name) { + var assignedValues = ctx.valuesAtLocation(name); boolean anyInvalid = false; for (Expression assignedValue : assignedValues) { - if (assignedValue.is(Tree.Kind.CALL_EXPR)) { - CallExpression callExpr = (CallExpression) assignedValue; - + if (assignedValue instanceof CallExpression callExpr && isInvalidResponseCall(callExpr)) { // Check if this Response has invalid arguments - if (isInvalidResponseCall(callExpr)) { - anyInvalid = true; - secondaryLocations.add(assignedValue); - } + anyInvalid = true; + secondaryLocations.add(assignedValue); } } if (anyInvalid) { return new ValidationResult(false, secondaryLocations); } - } else if (expr.is(Tree.Kind.CALL_EXPR)) { + } else if (expr instanceof CallExpression callExpr && isInvalidResponseCall(callExpr)) { // Direct Response constructor call - CallExpression callExpr = (CallExpression) expr; - if (isInvalidResponseCall(callExpr)) { - return new ValidationResult(false); - } + return new ValidationResult(false); } return new ValidationResult(true); diff --git a/python-checks/src/main/java/org/sonar/python/checks/IdenticalExpressionOnBinaryOperatorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IdenticalExpressionOnBinaryOperatorCheck.java index 796aa7803c..e1ae8db69a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IdenticalExpressionOnBinaryOperatorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IdenticalExpressionOnBinaryOperatorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IdentityComparisonWithCachedTypesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IdentityComparisonWithCachedTypesCheck.java index 2d2a0efa42..3dbbc899a3 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IdentityComparisonWithCachedTypesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IdentityComparisonWithCachedTypesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -29,9 +29,9 @@ import org.sonar.plugins.python.api.tree.IsExpression; import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.plugins.python.api.types.BuiltinTypes; import org.sonar.python.quickfix.TextEditUtils; import org.sonar.python.tree.TreeUtils; +import org.sonar.plugins.python.api.types.BuiltinTypes; import org.sonar.plugins.python.api.types.v2.PythonType; import org.sonar.python.types.v2.TypeCheckBuilder; import org.sonar.python.types.v2.TypeChecker; diff --git a/python-checks/src/main/java/org/sonar/python/checks/IdentityComparisonWithNewObjectCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IdentityComparisonWithNewObjectCheck.java index 4f3d8b421e..126b48c502 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IdentityComparisonWithNewObjectCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IdentityComparisonWithNewObjectCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IgnoredParameterCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IgnoredParameterCheck.java index 1f0cbb685f..26ced29a41 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IgnoredParameterCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IgnoredParameterCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -43,11 +43,15 @@ public class IgnoredParameterCheck extends PythonSubscriptionCheck { public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, ctx -> { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); - ControlFlowGraph cfg = ControlFlowGraph.build(functionDef, ctx.pythonFile()); + ControlFlowGraph cfg = ctx.cfg(functionDef); if (cfg == null) { return; } - LiveVariablesAnalysis lva = LiveVariablesAnalysis.analyze(cfg); + LiveVariablesAnalysis lva = ctx.lva(functionDef); + if (lva == null) { + return; + } + Set unreachableBlocks = CfgUtils.unreachableBlocks(cfg); cfg.blocks().forEach(block -> { var unnecessaryAssignments = DeadStoreUtils.findUnnecessaryAssignments(block, lva.getLiveVariables(block), functionDef); diff --git a/python-checks/src/main/java/org/sonar/python/checks/IgnoredPureOperationsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IgnoredPureOperationsCheck.java index dec50d4b84..8a616d028f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IgnoredPureOperationsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IgnoredPureOperationsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IgnoredSystemExitCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IgnoredSystemExitCheck.java index bbb984d2ca..e67d4af39f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IgnoredSystemExitCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IgnoredSystemExitCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ImplicitStringConcatenationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ImplicitStringConcatenationCheck.java index 0792d6af9c..0e1a010b26 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ImplicitStringConcatenationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ImplicitStringConcatenationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IncompatibleOperands.java b/python-checks/src/main/java/org/sonar/python/checks/IncompatibleOperands.java index 7f63caa14c..0f180beff2 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IncompatibleOperands.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IncompatibleOperands.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IncompatibleOperandsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IncompatibleOperandsCheck.java index f876964838..0c104dd69e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IncompatibleOperandsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IncompatibleOperandsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IncompleteComparisonMethodsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IncompleteComparisonMethodsCheck.java new file mode 100644 index 0000000000..b8b3d07181 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/IncompleteComparisonMethodsCheck.java @@ -0,0 +1,128 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.BaseTreeVisitor; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S8500") +public class IncompleteComparisonMethodsCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Add the missing comparison methods or use \"functools.total_ordering\"."; + private static final String SECONDARY_MESSAGE = "\"%s\" is defined here."; + + private static final Set ORDERING_METHODS = Set.of("__lt__", "__le__", "__gt__", "__ge__"); + + private static final TypeMatcher TOTAL_ORDERING_MATCHER = TypeMatchers.withFQN("functools.total_ordering"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, IncompleteComparisonMethodsCheck::checkClassDef); + } + + private static void checkClassDef(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + + CollectOrderingMethodNamesVisitor visitor = new CollectOrderingMethodNamesVisitor(); + classDef.body().accept(visitor); + + if (visitor.definitions.isEmpty() || visitor.definitions.size() == ORDERING_METHODS.size()) { + return; + } + + for (Decorator decorator : classDef.decorators()) { + if (TOTAL_ORDERING_MATCHER.isTrueFor(decorator.expression(), ctx)) { + return; + } + } + + PreciseIssue issue = ctx.addIssue(classDef.name(), MESSAGE); + visitor.definitions.forEach((name, tree) -> issue.secondary(tree, String.format(SECONDARY_MESSAGE, name))); + } + + /** + * Collects ordering methods defined at the top level of a class body, whether they are + * introduced by a {@code def} or by an assignment such as {@code __lt__ = lambda ...}. + * The map preserves the first occurrence per name in source order, which keeps secondary + * locations stable when a method is shadowed. + * Mirrors the recursion-control pattern of {@code TreeUtils.CollectFunctionDefsVisitor}: + * does not descend into nested classes or nested functions. + */ + private static class CollectOrderingMethodNamesVisitor extends BaseTreeVisitor { + private final Map definitions = new LinkedHashMap<>(); + + @Override + public void visitClassDef(ClassDef nestedClass) { + // Do not descend into nested classes + } + + @Override + public void visitFunctionDef(FunctionDef functionDef) { + Name name = functionDef.name(); + if (ORDERING_METHODS.contains(name.name())) { + definitions.putIfAbsent(name.name(), name); + } + // Do not descend into nested functions + } + + @Override + public void visitAssignmentStatement(AssignmentStatement assignment) { + assignmentTargetName(assignment) + .filter(name -> ORDERING_METHODS.contains(name.name())) + .ifPresent(name -> definitions.putIfAbsent(name.name(), name)); + super.visitAssignmentStatement(assignment); + } + + @Override + public void visitAnnotatedAssignment(AnnotatedAssignment annotated) { + if (annotated.assignedValue() != null && annotated.variable() instanceof Name name && ORDERING_METHODS.contains(name.name())) { + definitions.putIfAbsent(name.name(), name); + } + super.visitAnnotatedAssignment(annotated); + } + + private static Optional assignmentTargetName(AssignmentStatement assignment) { + List lhsList = assignment.lhsExpressions(); + if (lhsList.size() != 1) { + return Optional.empty(); + } + List expressions = lhsList.get(0).expressions(); + if (expressions.size() == 1 && expressions.get(0) instanceof Name name) { + return Optional.of(name); + } + return Optional.empty(); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/InconsistentTupleReturnCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InconsistentTupleReturnCheck.java new file mode 100644 index 0000000000..d09ff83d78 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/InconsistentTupleReturnCheck.java @@ -0,0 +1,114 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.List; +import java.util.OptionalInt; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.ReturnStatement; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.Tuple; + +@Rule(key = "S8495") +public class InconsistentTupleReturnCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Refactor this function to always return tuples of the same length."; + private static final String SECONDARY_MESSAGE = "Returns a %d-tuple."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, InconsistentTupleReturnCheck::checkFunction); + } + + private static void checkFunction(SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + + ReturnCheckUtils.ReturnStmtCollector collector = ReturnCheckUtils.ReturnStmtCollector.collect(functionDef); + + if (collector.containsYield()) { + return; + } + + List returnStmts = collector.getReturnStmts(); + + List tupleReturns = new ArrayList<>(); + for (ReturnStatement returnStmt : returnStmts) { + OptionalInt length = getTupleLengthIfTupleReturn(returnStmt); + if (length.isPresent()) { + tupleReturns.add(new ReturnWithLength(returnStmt, length.getAsInt())); + } + } + + if (tupleReturns.size() < 2) { + return; + } + + int firstLength = tupleReturns.get(0).length; + boolean allSame = tupleReturns.stream().allMatch(r -> r.length == firstLength); + if (allSame) { + return; + } + + PreciseIssue issue = ctx.addIssue(functionDef.name(), MESSAGE); + for (ReturnWithLength tupleReturn : tupleReturns) { + issue.secondary(tupleReturn.returnStmt, String.format(SECONDARY_MESSAGE, tupleReturn.length)); + } + } + + private static boolean containsUnpacking(List exprs) { + return exprs.stream().anyMatch(e -> e.is(Tree.Kind.UNPACKING_EXPR)); + } + + private static OptionalInt getTupleLengthIfTupleReturn(ReturnStatement returnStmt) { + List expressions = returnStmt.expressions(); + if (expressions.isEmpty()) { + return OptionalInt.empty(); + } + if (expressions.size() > 1) { + // Implicit tuple: return a, b — skip if any element is a star expression + if (containsUnpacking(expressions)) { + return OptionalInt.empty(); + } + return OptionalInt.of(expressions.size()); + } + // Single expression - check if it's an explicit tuple literal + Expression expr = expressions.get(0); + if (expr.is(Tree.Kind.TUPLE)) { + Tuple tuple = (Tuple) expr; + if (containsUnpacking(tuple.elements())) { + return OptionalInt.empty(); + } + return OptionalInt.of(tuple.elements().size()); + } + return OptionalInt.empty(); + } + + private static class ReturnWithLength { + final ReturnStatement returnStmt; + final int length; + + ReturnWithLength(ReturnStatement returnStmt, int length) { + this.returnStmt = returnStmt; + this.length = length; + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/InconsistentTypeHintCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InconsistentTypeHintCheck.java index 909211ad9d..aff40d0814 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InconsistentTypeHintCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InconsistentTypeHintCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IncorrectExceptionTypeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IncorrectExceptionTypeCheck.java index 7616904918..84f3899ea4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IncorrectExceptionTypeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IncorrectExceptionTypeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IncorrectParameterDatetimeConstructorsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IncorrectParameterDatetimeConstructorsCheck.java index fd89aea51c..f4022b6a01 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IncorrectParameterDatetimeConstructorsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IncorrectParameterDatetimeConstructorsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -19,7 +19,6 @@ import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.Name; @@ -27,6 +26,8 @@ import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.UnaryExpression; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; @@ -36,6 +37,9 @@ public class IncorrectParameterDatetimeConstructorsCheck extends PythonSubscript private static final int MAX_YEAR = 9999; private static final String MESSAGE = "Provide a correct value for the `%s` parameter."; private static final String MESSAGE_SECONDARY_LOCATION = "An invalid value is assigned here."; + private static final TypeMatcher DATE_MATCHER = TypeMatchers.isType("datetime.date"); + private static final TypeMatcher TIME_MATCHER = TypeMatchers.isType("datetime.time"); + private static final TypeMatcher DATETIME_MATCHER = TypeMatchers.isType("datetime.datetime"); @Override public void initialize(Context context) { @@ -44,15 +48,12 @@ public void initialize(Context context) { private static void checkCallExpr(SubscriptionContext context) { CallExpression callExpression = (CallExpression) context.syntaxNode(); - Symbol calleeSymbol = callExpression.calleeSymbol(); - if (calleeSymbol == null) { - return; - } - if ("datetime.date".equals(calleeSymbol.fullyQualifiedName())) { + Expression callee = callExpression.callee(); + if (DATE_MATCHER.isTrueFor(callee, context)) { checkDate(context, callExpression); - } else if ("datetime.time".equals(calleeSymbol.fullyQualifiedName())) { + } else if (TIME_MATCHER.isTrueFor(callee, context)) { checkTime(context, callExpression); - } else if ("datetime.datetime".equals(calleeSymbol.fullyQualifiedName())) { + } else if (DATETIME_MATCHER.isTrueFor(callee, context)) { checkDate(context, callExpression); checkTime(context, callExpression, 3); } @@ -101,16 +102,20 @@ public Tree expression() { } private static ValueWithExpression getValue(Expression expression) { - if (expression.is(Tree.Kind.NUMERIC_LITERAL)) { - return new ValueWithExpression(((NumericLiteral) expression).valueAsLong(), expression); - } else if (expression.is(Tree.Kind.UNARY_MINUS)) { - UnaryExpression unaryExpression = (UnaryExpression) expression; - if (!unaryExpression.expression().is(Tree.Kind.NUMERIC_LITERAL)) { - return null; + try { + if (expression.is(Tree.Kind.NUMERIC_LITERAL)) { + return new ValueWithExpression(((NumericLiteral) expression).valueAsLong(), expression); + } else if (expression.is(Tree.Kind.UNARY_MINUS)) { + UnaryExpression unaryExpression = (UnaryExpression) expression; + if (!unaryExpression.expression().is(Tree.Kind.NUMERIC_LITERAL)) { + return null; + } + return new ValueWithExpression(-((NumericLiteral) unaryExpression.expression()).valueAsLong(), unaryExpression); + } else if (expression.is(Tree.Kind.NAME)) { + return Expressions.singleAssignedNonNameValue((Name) expression).map(IncorrectParameterDatetimeConstructorsCheck::getValue).orElse(null); } - return new ValueWithExpression(-((NumericLiteral) unaryExpression.expression()).valueAsLong(), unaryExpression); - } else if (expression.is(Tree.Kind.NAME)) { - return Expressions.singleAssignedNonNameValue((Name) expression).map(IncorrectParameterDatetimeConstructorsCheck::getValue).orElse(null); + } catch (NumberFormatException nfe) { + return null; } return null; } diff --git a/python-checks/src/main/java/org/sonar/python/checks/IndexMethodCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IndexMethodCheck.java index a924246350..f1ef7d4ff1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IndexMethodCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IndexMethodCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/InefficientDictIterationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InefficientDictIterationCheck.java index b3b116adb9..bc87602380 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InefficientDictIterationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InefficientDictIterationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/InequalityUsageCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InequalityUsageCheck.java index 9b35cf7b58..1e2b980a0b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InequalityUsageCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InequalityUsageCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/InfiniteRecursionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InfiniteRecursionCheck.java index 29e6d8d4bf..aaef73b437 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InfiniteRecursionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InfiniteRecursionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -26,7 +26,6 @@ import javax.annotation.CheckForNull; import javax.annotation.Nullable; import org.sonar.check.Rule; -import org.sonar.plugins.python.api.PythonFile; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.cfg.CfgBlock; import org.sonar.plugins.python.api.cfg.ControlFlowGraph; @@ -62,7 +61,7 @@ public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, ctx -> { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); List allRecursiveCalls = new ArrayList<>(); - boolean endBlockIsReachable = collectRecursiveCallsAndCheckIfEndBlockIsReachable(functionDef, ctx.pythonFile(), allRecursiveCalls); + boolean endBlockIsReachable = collectRecursiveCallsAndCheckIfEndBlockIsReachable(functionDef, ctx.cfg(functionDef), allRecursiveCalls); if (!allRecursiveCalls.isEmpty() && !endBlockIsReachable) { String message = String.format(MESSAGE, functionDef.isMethodDefinition() ? "method" : "function"); PreciseIssue issue = ctx.addIssue(functionDef.name(), message); @@ -71,13 +70,9 @@ public void initialize(Context context) { }); } - private static boolean collectRecursiveCallsAndCheckIfEndBlockIsReachable(FunctionDef functionDef, PythonFile pythonFile, List allRecursiveCalls) { + private static boolean collectRecursiveCallsAndCheckIfEndBlockIsReachable(FunctionDef functionDef, @Nullable ControlFlowGraph cfg, List allRecursiveCalls) { Symbol functionSymbol = functionDef.name().symbol(); - if (functionSymbol == null) { - return true; - } - ControlFlowGraph cfg = ControlFlowGraph.build(functionDef, pythonFile); - if (cfg == null) { + if (functionSymbol == null || cfg == null) { return true; } RecursiveCallCollector recursiveCallCollector = new RecursiveCallCollector(functionDef, functionSymbol); diff --git a/python-checks/src/main/java/org/sonar/python/checks/InitReturnsValueCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InitReturnsValueCheck.java index 4c56232d29..5ca3fd7499 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InitReturnsValueCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InitReturnsValueCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/InputInAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InputInAsyncCheck.java index be5c56cd24..aec5d1c8bc 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InputInAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InputInAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/InstanceAndClassMethodsAtLeastOnePositionalCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InstanceAndClassMethodsAtLeastOnePositionalCheck.java index 586cf56075..d1651a0973 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InstanceAndClassMethodsAtLeastOnePositionalCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InstanceAndClassMethodsAtLeastOnePositionalCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/InstanceMethodSelfAsFirstCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InstanceMethodSelfAsFirstCheck.java index c0b056e5dc..22ff1a3e64 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InstanceMethodSelfAsFirstCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InstanceMethodSelfAsFirstCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -93,6 +93,11 @@ private boolean isRelevantMethod(ClassDef classDef, ClassSymbol classSymbol, Fun return false; } + // Skip _generate_next_value_ in Enum subclasses: it is a static protocol method per the Python docs + if ("_generate_next_value_".equals(functionDef.name().name()) && classSymbol.isOrExtends("enum.Enum")) { + return false; + } + // Skip if the class has a ignored decorator if (functionDef.decorators().stream().anyMatch(this::isNonInstanceMethodDecorator)) { return false; diff --git a/python-checks/src/main/java/org/sonar/python/checks/InvalidOpenModeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InvalidOpenModeCheck.java index a693717534..9537e96da5 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InvalidOpenModeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InvalidOpenModeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -23,7 +23,6 @@ import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.Argument; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; @@ -32,6 +31,8 @@ import org.sonar.plugins.python.api.tree.StringElement; import org.sonar.plugins.python.api.tree.StringLiteral; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; @@ -41,13 +42,13 @@ public class InvalidOpenModeCheck extends PythonSubscriptionCheck { private static final String VALID_MODES = "rwatb+Ux"; private static final Pattern INVALID_CHARACTERS = Pattern.compile("[^" + VALID_MODES + "]"); private static final String MESSAGE = "Fix this invalid mode string."; + private static final TypeMatcher OPEN_MATCHER = TypeMatchers.isType("open"); @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { CallExpression callExpression = (CallExpression) ctx.syntaxNode(); - Symbol calleeSymbol = callExpression.calleeSymbol(); - if (calleeSymbol == null || !"open".equals(calleeSymbol.fullyQualifiedName())) { + if (!OPEN_MATCHER.isTrueFor(callExpression.callee(), ctx)) { return; } List arguments = callExpression.arguments(); diff --git a/python-checks/src/main/java/org/sonar/python/checks/InvariantReturnCheck.java b/python-checks/src/main/java/org/sonar/python/checks/InvariantReturnCheck.java index 480969b36b..d254f00f4d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/InvariantReturnCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/InvariantReturnCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -42,6 +42,7 @@ import org.sonar.plugins.python.api.tree.Tree.Kind; import org.sonar.plugins.python.api.tree.TryStatement; import org.sonar.plugins.python.api.tree.UnaryExpression; +import org.sonar.python.cfg.CfgUtils; import org.sonar.python.cfg.PythonCfgBranchingBlock; import org.sonar.python.tree.TreeUtils; @@ -62,7 +63,7 @@ public class InvariantReturnCheck extends PythonSubscriptionCheck { public void initialize(Context context) { context.registerSyntaxNodeConsumer(Kind.FUNCDEF, ctx -> { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); - ControlFlowGraph cfg = ControlFlowGraph.build(functionDef, ctx.pythonFile()); + ControlFlowGraph cfg = ctx.cfg(functionDef); if (cfg != null) { List latestExecutedBlocks = collectLatestExecutedBlocks(cfg); boolean allBlocksHaveReturnStatement = latestExecutedBlocks.stream().allMatch(LatestExecutedBlock::hasReturnStatement); @@ -80,17 +81,21 @@ public void initialize(Context context) { private static List collectLatestExecutedBlocks(ControlFlowGraph cfg) { List collectedBlocks = new ArrayList<>(); + Set reachableBlocks = CfgUtils.reachableBlocks(cfg); for (CfgBlock predecessor : cfg.end().predecessors()) { + if (!reachableBlocks.contains(predecessor)) { + continue; + } if (predecessor instanceof PythonCfgBranchingBlock pythonCfgBranchingBlock) { - collectBranchingBlock(collectedBlocks, pythonCfgBranchingBlock); - } else if (!endsWithElementKind(predecessor, Kind.RAISE_STMT)) { + collectBranchingBlock(collectedBlocks, pythonCfgBranchingBlock, reachableBlocks); + } else { collectedBlocks.add(new LatestExecutedBlock(predecessor)); } } return collectedBlocks; } - private static void collectBranchingBlock(List collectedBlocks, PythonCfgBranchingBlock branchingBlock) { + private static void collectBranchingBlock(List collectedBlocks, PythonCfgBranchingBlock branchingBlock, Set reachableBlocks) { Tree branchingTree = branchingBlock.branchingTree(); if (branchingTree.is(Kind.TRY_STMT)) { TryStatement tryStatement = (TryStatement) branchingTree; @@ -100,16 +105,20 @@ private static void collectBranchingBlock(List collectedBlo } else if (branchingTree.is(Kind.IF_STMT) || branchingTree instanceof Pattern) { collectedBlocks.add(new LatestExecutedBlock(branchingBlock)); } else { - collectBlocksHavingReturnBeforeExceptOrFinallyBlock(collectedBlocks, branchingBlock); + collectBlocksHavingReturnBeforeExceptOrFinallyBlock(collectedBlocks, branchingBlock, reachableBlocks); } } - private static void collectBlocksHavingReturnBeforeExceptOrFinallyBlock(List collectedBlocks, PythonCfgBranchingBlock branchingBlock) { + private static void collectBlocksHavingReturnBeforeExceptOrFinallyBlock(List collectedBlocks, PythonCfgBranchingBlock branchingBlock, + Set reachableBlocks) { if (branchingBlock.branchingTree().is(Kind.EXCEPT_CLAUSE, Kind.FINALLY_CLAUSE)) { for (CfgBlock predecessor : branchingBlock.predecessors()) { + if (!reachableBlocks.contains(predecessor)) { + continue; + } if (predecessor instanceof PythonCfgBranchingBlock pythonCfgBranchingBlock) { - collectBlocksHavingReturnBeforeExceptOrFinallyBlock(collectedBlocks, pythonCfgBranchingBlock); - } else if (endsWithElementKind(predecessor, Kind.RETURN_STMT)) { + collectBlocksHavingReturnBeforeExceptOrFinallyBlock(collectedBlocks, pythonCfgBranchingBlock, reachableBlocks); + } else if (endsWithElementKind(predecessor, Kind.RETURN_STMT) || endsWithElementKind(predecessor, Kind.RAISE_STMT)) { collectedBlocks.add(new LatestExecutedBlock(predecessor)); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/IsCloseAbsTolCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IsCloseAbsTolCheck.java index 7370f1f801..b0544b1d68 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IsCloseAbsTolCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IsCloseAbsTolCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -22,13 +22,14 @@ import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.quickfix.PythonQuickFix; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.NumericLiteral; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.quickfix.TextEditUtils; import org.sonar.python.tree.TreeUtils; @@ -39,6 +40,7 @@ public class IsCloseAbsTolCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Provide the \"abs_tol\" parameter when using \"math.isclose\" to compare a value to 0."; private static final String SECONDARY_LOCATION_MESSAGE = "This argument evaluates to zero."; private static final String QUICK_FIX_MESSAGE = "Add the \"abs_tol\" parameter."; + private static final TypeMatcher MATH_ISCLOSE = TypeMatchers.isType("math.isclose"); @Override public void initialize(Context context) { @@ -47,8 +49,7 @@ public void initialize(Context context) { } private static void checkForIsCloseAbsTolArgument(SubscriptionContext ctx, CallExpression call) { - Symbol symbol = call.calleeSymbol(); - if (symbol != null && "math.isclose".equals(symbol.fullyQualifiedName()) + if (MATH_ISCLOSE.isTrueFor(call.callee(), ctx) && TreeUtils.argumentByKeyword("abs_tol", call.arguments()) == null) { RegularArgument firstArg = TreeUtils.nthArgumentOrKeyword(0, "a", call.arguments()); RegularArgument secondArg = TreeUtils.nthArgumentOrKeyword(1, "b", call.arguments()); diff --git a/python-checks/src/main/java/org/sonar/python/checks/ItemOperationsType.java b/python-checks/src/main/java/org/sonar/python/checks/ItemOperationsType.java index 57a4f9c59f..9382ee1646 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ItemOperationsType.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ItemOperationsType.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ItemOperationsTypeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ItemOperationsTypeCheck.java index 8c348632fd..b7b0abff8c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ItemOperationsTypeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ItemOperationsTypeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IterMethodReturnTypeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IterMethodReturnTypeCheck.java index 2ebc629766..24a43eec90 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IterMethodReturnTypeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IterMethodReturnTypeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IterationOnNonIterable.java b/python-checks/src/main/java/org/sonar/python/checks/IterationOnNonIterable.java index e447be0e8a..8de74d3155 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IterationOnNonIterable.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IterationOnNonIterable.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/IterationOnNonIterableCheck.java b/python-checks/src/main/java/org/sonar/python/checks/IterationOnNonIterableCheck.java index c1d704bf02..f511d4aa0a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/IterationOnNonIterableCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/IterationOnNonIterableCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/JumpInFinallyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/JumpInFinallyCheck.java index 007a281e84..dcae33a537 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/JumpInFinallyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/JumpInFinallyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/JwtVerificationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/JwtVerificationCheck.java index 9314dc64f8..ac851f9acb 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/JwtVerificationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/JwtVerificationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -20,6 +20,7 @@ import java.util.List; import java.util.Optional; import java.util.Set; +import java.util.function.Predicate; import java.util.stream.Stream; import javax.annotation.Nullable; import org.sonar.check.Rule; @@ -27,22 +28,26 @@ import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.symbols.Usage; -import org.sonar.plugins.python.api.tree.Argument; import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.BinaryExpression; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.DictionaryLiteral; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.InExpression; import org.sonar.plugins.python.api.tree.KeyValuePair; import org.sonar.plugins.python.api.tree.ListLiteral; import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.QualifiedExpression; import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringElement; import org.sonar.plugins.python.api.tree.StringLiteral; import org.sonar.plugins.python.api.tree.SubscriptionExpression; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.Tree.Kind; import org.sonar.plugins.python.api.tree.Tuple; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; @@ -80,6 +85,14 @@ public class JwtVerificationCheck extends PythonSubscriptionCheck { public static final Set VERIFY_SIGNATURE_OPTION_SUPPORTING_FUNCTION_FQNS = Set.of("jose.jwt.decode", "jwt.decode"); + private static final Set EQUALITY_COMPARATORS = Set.of("==", "!="); + + private static final String ALGORITHMS_KEYWORD = "algorithms"; + + private static final Set ISSUER_CLAIM_KEY = Set.of("iss"); + + private static final TypeMatcher IS_ENUM_MATCHER = TypeMatchers.isOrExtendsType("enum.Enum"); + @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Kind.CALL_EXPR, JwtVerificationCheck::verifyCallExpression); @@ -96,7 +109,7 @@ private static void verifyCallExpression(SubscriptionContext ctx) { String calleeFqn = calleeSymbol.fullyQualifiedName(); if (WHERE_VERIFY_KWARG_SHOULD_BE_TRUE_FQNS.contains(calleeFqn)) { RegularArgument verifyArg = TreeUtils.argumentByKeyword("verify", call.arguments()); - if (verifyArg != null && Expressions.isFalsy(verifyArg.expression())) { + if (verifyArg != null && Expressions.isFalsy(verifyArg.expression()) && !isVerifiedElsewhere(call) && !isIssuerRoutingPattern(call, ctx)) { ctx.addIssue(verifyArg, MESSAGE); return; } @@ -114,10 +127,214 @@ private static void verifyCallExpression(SubscriptionContext ctx) { Optional.ofNullable(TreeUtils.argumentByKeyword("options", call.arguments())) .map(RegularArgument::expression) .filter(JwtVerificationCheck::isListOrDictWithSensitiveEntry) + .filter(expression -> !isVerifiedElsewhere(call) && !isIssuerRoutingPattern(call, ctx)) .ifPresent(expression -> ctx.addIssue(expression, MESSAGE)); } } + /** + * "Peek then verify" pattern (multi-tenant JWT key discovery): an unverified decode of a token is + * compliant if the same token is decoded again elsewhere in the same function/module with real + * signature verification. If the token argument can't be resolved to a symbol, we can't disprove + * such a call exists, so we assume compliance rather than raise a false positive. + */ + private static boolean isVerifiedElsewhere(CallExpression unverifiedCall) { + Symbol tokenSymbol = tokenArgumentSymbol(unverifiedCall); + if (tokenSymbol == null) { + return true; + } + Tree scope = TreeUtils.firstAncestorOfKind(unverifiedCall, Kind.FILE_INPUT, Kind.FUNCDEF); + return scope != null && TreeUtils.hasDescendant(scope, tree -> isVerifyingCallOnToken(tree, unverifiedCall, tokenSymbol)); + } + + private static boolean isVerifyingCallOnToken(Tree tree, CallExpression unverifiedCall, Symbol tokenSymbol) { + return TreeUtils.toOptionalInstanceOf(CallExpression.class, tree) + .filter(call -> call != unverifiedCall) + .filter(JwtVerificationCheck::isDecodeOrVerifyCall) + .filter(call -> tokenSymbol.equals(tokenArgumentSymbol(call))) + .filter(call -> !isUnverifiedShape(call)) + .filter(JwtVerificationCheck::hasKeyArgument) + .isPresent(); + } + + private static boolean hasKeyArgument(CallExpression call) { + RegularArgument keyArg = TreeUtils.nthArgumentOrKeyword(1, "key", call.arguments()); + return keyArg != null && !Expressions.isFalsy(keyArg.expression()); + } + + private static boolean isDecodeOrVerifyCall(CallExpression call) { + return Optional.ofNullable(call.calleeSymbol()) + .map(Symbol::fullyQualifiedName) + .filter(fqn -> WHERE_VERIFY_KWARG_SHOULD_BE_TRUE_FQNS.contains(fqn) || VERIFY_SIGNATURE_OPTION_SUPPORTING_FUNCTION_FQNS.contains(fqn)) + .isPresent(); + } + + private static boolean isUnverifiedShape(CallExpression call) { + RegularArgument verifyArg = TreeUtils.argumentByKeyword("verify", call.arguments()); + if (verifyArg != null && Expressions.isFalsy(verifyArg.expression())) { + return true; + } + return Optional.ofNullable(TreeUtils.argumentByKeyword("options", call.arguments())) + .map(RegularArgument::expression) + .filter(JwtVerificationCheck::isListOrDictWithSensitiveEntry) + .isPresent(); + } + + @Nullable + private static Symbol tokenArgumentSymbol(CallExpression call) { + return Optional.ofNullable(TreeUtils.nthArgumentOrKeyword(0, "jwt", call.arguments())) + .map(RegularArgument::expression) + .filter(expression -> expression.is(Kind.NAME)) + .map(expression -> ((Name) expression).symbol()) + .orElse(null); + } + + /** + * "Issuer routing" pattern: an unverified decode is compliant if its payload's ONLY use is reading the + * {@code iss} claim, and that issuer is then checked against a static whitelist (enum conversion, set/list/tuple + * membership, or an all-literal-keys dict lookup) - the real signature verification typically happens in the + * caller, using a key resolved from the whitelisted issuer, so unlike {@link #isVerifiedElsewhere} this doesn't + * require the same token to be re-decoded in this function. No ordering is enforced between the payload access + * and the whitelist check (unlike {@link #isValidatedBeforeAlgorithmsUse}) - there's no sink this rule can see + * the issuer flow into (the resolved key is typically returned or passed to a caller-supplied parameter), so + * there's nothing to protect by requiring the whitelist check to come first. + */ + private static boolean isIssuerRoutingPattern(CallExpression unverifiedCall, SubscriptionContext ctx) { + Tree assignment = TreeUtils.firstAncestorOfKind(unverifiedCall, Tree.Kind.ASSIGNMENT_STMT); + if (assignment == null) { + return false; + } + List lhsExpressions = ((AssignmentStatement) assignment).lhsExpressions().stream() + .map(ExpressionList::expressions) + .flatMap(Collection::stream).toList(); + if (lhsExpressions.size() != 1 || !lhsExpressions.get(0).is(Tree.Kind.NAME)) { + return false; + } + Symbol payloadSymbol = ((Name) lhsExpressions.get(0)).symbol(); + if (payloadSymbol == null) { + return false; + } + List usages = getForwardUsages(payloadSymbol, unverifiedCall).toList(); + if (usages.isEmpty()) { + return false; + } + Tree scope = TreeUtils.firstAncestorOfKind(unverifiedCall, Kind.FILE_INPUT, Kind.FUNCDEF); + return scope != null && usages.stream().allMatch(usage -> isIssuerClaimAccessWhitelistedElsewhere(usage, scope, ctx)); + } + + /** + * Whether one usage of the payload Name is a `.get("iss")`/`["iss"]` access whose extracted value (the issuer) + * is validated against a static whitelist somewhere in {@code scope} - either via the Name it's assigned to + * ({@link #isIssuerWhitelisted}), or, when never assigned at all, by being a direct operand of an inline + * `in`/`not in` membership check against a literal collection ({@link #isInlineLiteralMembershipOperand}). + * The inline case mirrors the same "no trackable symbol" limitation {@link #extractedValueSymbol} already + * has for the algorithm-validation pattern elsewhere in this file - see review discussion on PR #1294. + */ + private static boolean isIssuerClaimAccessWhitelistedElsewhere(Usage usage, Tree scope, SubscriptionContext ctx) { + Tree usageParent = usage.tree().parent(); + Optional getCall = getCallExprWhereDictIsAccessedWithGet(Stream.of(usageParent)).findFirst(); + if (getCall.isPresent()) { + Stream keys = getStringLiteralKeyArgument(getCall.get()); + return isIssuerClaimKey(keys) && (isIssuerWhitelisted(getCall.get(), scope, ctx) || isInlineLiteralMembershipOperand(getCall.get())); + } + Optional subscription = getSubscriptions(Stream.of(usageParent)).findFirst(); + if (subscription.isPresent()) { + Stream keys = getSubscriptsStringLiteral(Stream.of(subscription.get())); + return isIssuerClaimKey(keys) && (isIssuerWhitelisted(subscription.get(), scope, ctx) || isInlineLiteralMembershipOperand(subscription.get())); + } + return false; + } + + /** + * Whether {@code extractionSite} (e.g. {@code payload.get("iss")}) is itself a direct operand of an + * `in`/`not in` check against a literal string collection, e.g. {@code payload.get("iss") not in {"a", "b"}}. + * Unlike {@link #isLiteralMembershipGuardOnSymbol}, this needs no assignment/symbol - the extraction site is + * checked directly, covering the case where the claim is compared without ever being bound to a variable. + */ + private static boolean isInlineLiteralMembershipOperand(Tree extractionSite) { + return TreeUtils.toOptionalInstanceOf(InExpression.class, extractionSite.parent()) + .filter(inExpr -> inExpr.leftOperand() == extractionSite) + .map(InExpression::rightOperand) + .flatMap(Expressions::ifNameGetSingleAssignedNonNameValue) + .map(Expressions::expressionsFromListOrTuple) + .filter(elements -> !elements.isEmpty() && elements.stream().allMatch(JwtVerificationCheck::isNonInterpolatedStringLiteral)) + .isPresent(); + } + + private static boolean isNonInterpolatedStringLiteral(Expression element) { + return TreeUtils.toOptionalInstanceOf(StringLiteral.class, element) + .filter(literal -> literal.stringElements().stream().noneMatch(StringElement::isInterpolated)) + .isPresent(); + } + + private static boolean isIssuerClaimKey(Stream keyLiterals) { + List keys = keyLiterals.toList(); + return !keys.isEmpty() && keys.stream().allMatch(str -> ISSUER_CLAIM_KEY.contains(str.trimmedQuotesValue())); + } + + private static boolean isIssuerWhitelisted(Tree issuerExtractionSite, Tree scope, SubscriptionContext ctx) { + Optional issuerSymbol = extractedValueSymbol(issuerExtractionSite); + if (issuerSymbol.isEmpty()) { + return false; + } + Symbol symbol = issuerSymbol.get(); + return TreeUtils.hasDescendant(scope, tree -> isEnumConversionOfSymbol(tree, symbol, ctx)) + || TreeUtils.hasDescendant(scope, tree -> isLiteralMembershipGuardOnSymbol(tree, symbol)) + || TreeUtils.hasDescendant(scope, tree -> isDictLookupOnSymbolWithLiteralKeys(tree, symbol)); + } + + /** + * Whether {@code tree} is `symbol in [...]`/`symbol not in [...]` against a list/tuple/set literal (or a Name + * bound to one) whose elements are ALL string literals. Stricter than {@link #isAllowlistGuardOnSymbol} - that + * one only requires the guard to exist (enough to prevent algorithm confusion, since any real check beats none), + * but the ticket's "static whitelist" requirement here means a guard containing even one dynamic element + * (`issuer in {"a", dynamic_value}`) doesn't qualify: the whitelist isn't actually static. + */ + private static boolean isLiteralMembershipGuardOnSymbol(Tree tree, Symbol symbol) { + return TreeUtils.toOptionalInstanceOf(InExpression.class, tree) + .filter(inExpr -> isNameOfSymbol(inExpr.leftOperand(), symbol)) + .map(InExpression::rightOperand) + .flatMap(Expressions::ifNameGetSingleAssignedNonNameValue) + .map(Expressions::expressionsFromListOrTuple) + .filter(elements -> !elements.isEmpty() && elements.stream().allMatch(JwtVerificationCheck::isNonInterpolatedStringLiteral)) + .isPresent(); + } + + /** Whether {@code tree} is a call passing {@code symbol} to a callee whose type is a declared Enum subclass, e.g. {@code AuthIssuer(issuer)}. */ + private static boolean isEnumConversionOfSymbol(Tree tree, Symbol symbol, SubscriptionContext ctx) { + return TreeUtils.toOptionalInstanceOf(CallExpression.class, tree) + .filter(call -> call.arguments().stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(RegularArgument.class)) + .map(RegularArgument::expression) + .anyMatch(expression -> isNameOfSymbol(expression, symbol))) + .map(CallExpression::callee) + .filter(callee -> IS_ENUM_MATCHER.isTrueFor(callee, ctx)) + .isPresent(); + } + + /** Whether {@code tree} is `symbol[key]` (or `key = symbol[...]`'s RHS) where the subscripted base is a dict literal with only string-literal keys. */ + private static boolean isDictLookupOnSymbolWithLiteralKeys(Tree tree, Symbol symbol) { + return TreeUtils.toOptionalInstanceOf(SubscriptionExpression.class, tree) + .filter(subscription -> subscription.subscripts().expressions().stream().anyMatch(expression -> isNameOfSymbol(expression, symbol))) + .map(SubscriptionExpression::object) + .flatMap(Expressions::ifNameGetSingleAssignedNonNameValue) + .flatMap(TreeUtils.toOptionalInstanceOfMapper(DictionaryLiteral.class)) + .filter(JwtVerificationCheck::hasOnlyStringLiteralKeys) + .isPresent(); + } + + private static boolean hasOnlyStringLiteralKeys(DictionaryLiteral dictionaryLiteral) { + if (dictionaryLiteral.elements().isEmpty()) { + return false; + } + List pairs = dictionaryLiteral.elements().stream() + .filter(KeyValuePair.class::isInstance) + .map(KeyValuePair.class::cast) + .toList(); + return pairs.size() == dictionaryLiteral.elements().size() + && pairs.stream().allMatch(pair -> pair.key().is(Kind.STRING_LITERAL)); + } + private static boolean isListOrDictWithSensitiveEntry(@Nullable Expression expression) { if (expression == null) { return false; @@ -182,56 +399,228 @@ private static boolean isCallToVerifyJwt(Tree t) { .isPresent(); } + /** + * Fail-open: a call is compliant unless a concrete unsafe usage of the header/claims value (or a value + * extracted from it) is found. A usage shape this check doesn't recognize is not, by itself, grounds to raise - + * only known-unsafe sinks (bare pass-through, return, disallowed key access) do, unless that same usage also + * matches one of the safe patterns (allowed key, comparison-only, or validated-then-used-as-algorithm). + */ private static boolean accessOnlyAllowedHeaderKeys(CallExpression call) { + // the call's own result can itself be a comparison operand, e.g. `jwt.get_unverified_header(token) == expected` + // - here `call` is the operand, not `call.parent()` (which is already the COMPARISON node), unlike the + // `.get(...)`/`[...]` chained-access shapes below where the extra level of nesting means the parent is + // the right thing to inspect. + if (isComparisonOperand(call)) { + return true; + } + // direct chained access on the call's own result, e.g. `jwt.get_unverified_header(token).get("x5u")`, + // is always checked - independent of whether the whole chained expression is itself assigned to some + // unrelated name (`x5u = jwt.get_unverified_header(token).get("x5u")`). + if (isSafeUsageSite(call.parent())) { + return true; + } Tree assignment = TreeUtils.firstAncestorOfKind(call, Tree.Kind.ASSIGNMENT_STMT); - Stream headerKeysAccessedDirectly = accessToHeaderKeyWithoutAssignment(call); if (assignment == null) { - return areStringLiteralsPartOfAllowedKeys(headerKeysAccessedDirectly); - } else { - List lhsExpressions = ((AssignmentStatement) assignment).lhsExpressions().stream() - .map(ExpressionList::expressions) - .flatMap(Collection::stream).toList(); - if (lhsExpressions.size() == 1 && lhsExpressions.get(0).is(Tree.Kind.NAME)) { - Name name = (Name) lhsExpressions.get(0); - Symbol symbol = name.symbol(); - if (symbol != null) { - Stream argumentsOfGet = usagesAccessedByGet(symbol, call); - Stream argumentsOfSubscription = usagesAccessedBySubscription(symbol, call); - Stream headerKeysAccessFromAssignedValues = Stream.concat(argumentsOfGet, argumentsOfSubscription); - return areStringLiteralsPartOfAllowedKeys(Stream.concat(headerKeysAccessFromAssignedValues, headerKeysAccessedDirectly)); - } + return false; + } + List lhsExpressions = ((AssignmentStatement) assignment).lhsExpressions().stream() + .map(ExpressionList::expressions) + .flatMap(Collection::stream).toList(); + if (lhsExpressions.size() == 1 && lhsExpressions.get(0).is(Tree.Kind.NAME)) { + Name name = (Name) lhsExpressions.get(0); + Symbol symbol = name.symbol(); + if (symbol != null) { + Tree scope = TreeUtils.firstAncestorOfKind(call, Kind.FILE_INPUT, Kind.FUNCDEF); + List usages = getForwardUsages(symbol, call).toList(); + return !usages.isEmpty() && usages.stream().allMatch(usage -> isSafeUsage(usage, scope)); } } return false; } - private static boolean areStringLiteralsPartOfAllowedKeys(Stream literals) { - var literalList = literals.toList(); - return !literalList.isEmpty() && literalList.stream().allMatch(str -> ALLOWED_KEYS_ACCESS.contains(str.trimmedQuotesValue())); + /** + * Classifies one forward usage of the header/claims Name (e.g. the `header` in `header = jwt.get_unverified_header(token)`). + * Two things can make a usage safe, checked at two different tree depths: + * - the bare Name itself is compared (`header == expected`) - checked directly on {@code usage.tree()}; + * - a value extracted from it via `.get(key)`/`[key]` is either an allowed key, compared, or validated-then-used + * as an algorithm - checked on {@code usageParent}, which is the `.get(...)` call or `[...]` subscription + * sitting immediately on top of this usage. + * Anything else (bare pass-through, `return header`, disallowed key) falls through to `false` - this is the + * pre-existing sink detection carried over unchanged from before this ticket, not a new way to raise issues. + */ + private static boolean isSafeUsage(Usage usage, @Nullable Tree scope) { + Tree usageParent = usage.tree().parent(); + if (isComparisonOperand(usage.tree())) { + return true; + } + Optional getCall = getCallExprWhereDictIsAccessedWithGet(Stream.of(usageParent)).findFirst(); + if (getCall.isPresent()) { + Stream keys = getStringLiteralKeyArgument(getCall.get()); + return isSafeExtractedValueSite(getCall.get(), keys, scope); + } + Optional subscription = getSubscriptions(Stream.of(usageParent)).findFirst(); + if (subscription.isPresent()) { + Stream keys = getSubscriptsStringLiteral(Stream.of(subscription.get())); + return isSafeExtractedValueSite(subscription.get(), keys, scope); + } + return false; + } + + /** + * Whether a value extracted from the header (e.g. the `.get("alg")` call itself, or a `["alg"]` subscription) + * is safe to use unrestricted: it's directly compared, its key is in the {@link #ALLOWED_KEYS_ACCESS} allowlist, + * or (algorithm pattern only) it's validated against an allowlist before being used as `algorithms=`. + */ + private static boolean isSafeExtractedValueSite(Tree extractionSite, Stream keyLiterals, @Nullable Tree scope) { + if (isComparisonOperand(extractionSite)) { + return true; + } + List keys = keyLiterals.toList(); + if (!keys.isEmpty() && keys.stream().allMatch(str -> ALLOWED_KEYS_ACCESS.contains(str.trimmedQuotesValue()))) { + return true; + } + return scope != null && isValidatedBeforeAlgorithmsUse(extractionSite, scope); + } + + /** Whether {@code tree}'s parent is a `==`/`!=` comparison with {@code tree} as one of its two operands. */ + private static boolean isComparisonOperand(Tree extractionSiteOrName) { + Tree parent = extractionSiteOrName.parent(); + if (!parent.is(Kind.COMPARISON)) { + return false; + } + return EQUALITY_COMPARATORS.contains(((BinaryExpression) parent).operator().value()); + } + + /** + * Whether {@code extractionSite} (e.g. {@code header.get("alg")}) flows, via the Name it's assigned to, into an + * {@code in}/{@code not in} check against a literal list/tuple allowlist that appears strictly before the + * value is passed as the {@code algorithms=} argument to a decode/verify call, anywhere in {@code scope}. + * Line position is used as a lightweight ordering proxy rather than full control-flow dominance, matching + * this file's existing line-number heuristics (e.g. {@link #getForwardUsages}) - the guard must be found + * on an earlier line than the algorithms= use, otherwise the algorithm-confusion attack this rule targets + * (using an unvalidated alg to decode, then validating too late or in unreachable code) would go undetected. + */ + private static boolean isValidatedBeforeAlgorithmsUse(Tree extractionSite, Tree scope) { + Optional symbol = extractedValueSymbol(extractionSite); + if (symbol.isEmpty()) { + return false; + } + Optional guardLine = firstDescendantLine(scope, tree -> isAllowlistGuardOnSymbol(tree, symbol.get())); + Optional algorithmsUseLine = firstDescendantLine(scope, tree -> isAlgorithmsArgumentUsingSymbol(tree, symbol.get())); + return guardLine.isPresent() && algorithmsUseLine.isPresent() && guardLine.get() < algorithmsUseLine.get(); + } + + private static Optional firstDescendantLine(Tree tree, Predicate predicate) { + for (Tree child : tree.children()) { + if (predicate.test(child)) { + return Optional.of(child.firstToken().line()); + } + Optional nested = firstDescendantLine(child, predicate); + if (nested.isPresent()) { + return nested; + } + } + return Optional.empty(); } - private static Stream accessToHeaderKeyWithoutAssignment(CallExpression call) { - Stream callExpressionFromGetUnverifiedHeaders = getCallExprWhereDictIsAccessedWithGet(Stream.of(call.parent())); - Stream argumentsOfCallExpr = getArgumentsFromCallExpr(callExpressionFromGetUnverifiedHeaders); - Stream stringLiteralArgumentsFromGet = getStringLiteralArguments(argumentsOfCallExpr); - Stream subscriptionFromGetUnverifiedHeaders = getSubscriptions(Stream.of(call.parent())); - Stream stringLiteralArgumentFromSubscription = getSubscriptsStringLiteral(subscriptionFromGetUnverifiedHeaders); - return Stream.concat(stringLiteralArgumentsFromGet, stringLiteralArgumentFromSubscription); + /** + * The symbol a `.get(key)`/`[key]` extraction result is bound to, e.g. `alg` in `alg = header.get("alg")`. + * Only handles the direct single-Name-LHS shape; if the extraction is used inline (e.g. + * `algorithms=[header.get("alg")]`) or the target isn't a plain Name, there's no symbol to track the + * value's later validation/use through, so this - and therefore the algorithm-validation pattern - doesn't + * apply. That's intentional: without a trackable symbol we can't confirm the value was validated, so the + * usage falls through to the pre-existing sink detection in {@link #isSafeUsage} instead of being exempted. + */ + private static Optional extractedValueSymbol(Tree extractionSite) { + Tree assignment = TreeUtils.firstAncestorOfKind(extractionSite, Kind.ASSIGNMENT_STMT); + return Optional.ofNullable(assignment) + .map(AssignmentStatement.class::cast) + .map(AssignmentStatement::lhsExpressions) + .filter(list -> list.size() == 1) + .map(list -> list.get(0).expressions()) + .filter(list -> list.size() == 1 && list.get(0).is(Kind.NAME)) + .map(list -> ((Name) list.get(0)).symbol()); } - private static Stream usagesAccessedByGet(Symbol symbol, CallExpression call) { - var usages = getForwardUsages(symbol, call); - var parentOfUsages = usages.map(Usage::tree).map(Tree::parent); - var callExpressionsFromUsages = getCallExprWhereDictIsAccessedWithGet(parentOfUsages); - return getStringLiteralArguments(getArgumentsFromCallExpr(callExpressionsFromUsages)); + /** Whether {@code tree} is `symbol in [...]`/`symbol not in [...]` against a literal list/tuple (or a Name bound to one). */ + private static boolean isAllowlistGuardOnSymbol(Tree tree, Symbol symbol) { + return TreeUtils.toOptionalInstanceOf(InExpression.class, tree) + .filter(inExpr -> isNameOfSymbol(inExpr.leftOperand(), symbol)) + .map(InExpression::rightOperand) + .flatMap(Expressions::ifNameGetSingleAssignedNonNameValue) + .map(Expressions::expressionsFromListOrTuple) + .filter(elements -> !elements.isEmpty()) + .isPresent(); } - private static Stream getArgumentsFromCallExpr(Stream callExprs) { - return callExprs.map(CallExpression::arguments).flatMap(Collection::stream); + /** Whether {@code tree} is a `jwt.decode`/`jose.jwt.decode` call whose `algorithms=` argument uses {@code symbol}. */ + private static boolean isAlgorithmsArgumentUsingSymbol(Tree tree, Symbol symbol) { + return TreeUtils.toOptionalInstanceOf(CallExpression.class, tree) + .map(CallExpression::calleeSymbol) + .map(Symbol::fullyQualifiedName) + .filter(VERIFY_SIGNATURE_OPTION_SUPPORTING_FUNCTION_FQNS::contains) + .map(fqn -> ((CallExpression) tree).arguments()) + .map(arguments -> TreeUtils.argumentByKeyword(ALGORITHMS_KEYWORD, arguments)) + .map(RegularArgument::expression) + .filter(algorithms -> algorithmsExpressionUsesSymbol(algorithms, symbol)) + .isPresent(); + } + + private static boolean algorithmsExpressionUsesSymbol(Expression algorithms, Symbol symbol) { + if (isNameOfSymbol(algorithms, symbol)) { + return true; + } + return Expressions.expressionsFromListOrTuple(algorithms).stream().anyMatch(element -> isNameOfSymbol(element, symbol)); } + private static boolean isNameOfSymbol(Expression expression, Symbol symbol) { + return expression.is(Kind.NAME) && symbol.equals(((Name) expression).symbol()); + } + + /** + * Same safety check as {@link #isSafeExtractedValueSite}, but for the "no assignment" path where the header + * result is chain-accessed directly (`jwt.get_unverified_header(token).get("x5u")`) instead of first bound + * to a Name. There's no extracted-value symbol to track here, so only comparison and allowed-key access + * apply - the algorithm-validation pattern needs a Name to check the `in`/`not in` guard against, see + * {@link #extractedValueSymbol}. {@code usageSite} is the node directly above the call - i.e. the + * `QualifiedExpression` for `.get(...)` chains or the `SubscriptionExpression` for `[...]` - so the + * comparison check must run on the resolved `.get(...)` call / subscription itself, not on {@code usageSite}: + * for a `.get(...)` chain, {@code usageSite} is the intermediate `.get` qualified expression, which is never + * itself a comparison operand (its parent is always the enclosing call). + */ + private static boolean isSafeUsageSite(Tree usageSite) { + Optional getCall = getCallExprWhereDictIsAccessedWithGet(Stream.of(usageSite)).findFirst(); + if (getCall.isPresent()) { + if (isComparisonOperand(getCall.get())) { + return true; + } + return isAllowedKeyAccess(getStringLiteralKeyArgument(getCall.get())); + } + Optional subscription = getSubscriptions(Stream.of(usageSite)).findFirst(); + if (subscription.isPresent()) { + if (isComparisonOperand(subscription.get())) { + return true; + } + return isAllowedKeyAccess(getSubscriptsStringLiteral(Stream.of(subscription.get()))); + } + return false; + } + + private static boolean isAllowedKeyAccess(Stream keyLiterals) { + List keys = keyLiterals.toList(); + return !keys.isEmpty() && keys.stream().allMatch(str -> ALLOWED_KEYS_ACCESS.contains(str.trimmedQuotesValue())); + } + + /** + * All reads of {@code symbol} after {@code call}, using line number as a cheap proxy for "later" (this file + * doesn't do real control-flow analysis). Binding usages are excluded: if the same variable name is rebound + * later in the function (`header = jwt.get_unverified_header(token)` again), that's a fresh, independently + * checked call, not a use of *this* call's result - counting it here would attribute a later call's usages + * to this one and could wrongly flag (or wrongly clear) either call based on the other's usages. + */ private static Stream getForwardUsages(Symbol symbol, CallExpression call) { return symbol.usages().stream() + .filter(usage -> !usage.isBindingUsage()) .filter(usage -> usage.tree().firstToken().line() > call.callee().firstToken().line()); } @@ -245,18 +634,17 @@ private static Stream getCallExprWhereDictIsAccessedWithGet(Stre .flatMap(TreeUtils.toStreamInstanceOfMapper(CallExpression.class)); } - private static Stream getStringLiteralArguments(Stream arguments) { - return arguments.filter(arg -> arg.is(Tree.Kind.REGULAR_ARGUMENT)) - .flatMap(TreeUtils.toStreamInstanceOfMapper(RegularArgument.class)) + /** + * The `.get(key)` call's key argument, as a StringLiteral if it is one. Only the first positional/keyword + * argument is considered - `.get(key, default)`'s second argument is a fallback value, not part of the key, + * and must not be treated as an additional accessed key (e.g. `header.get("kid", "fallback")` must still be + * recognized as accessing only `"kid"`, not `{"kid", "fallback"}`). + */ + private static Stream getStringLiteralKeyArgument(CallExpression getCall) { + return Optional.ofNullable(TreeUtils.nthArgumentOrKeyword(0, "key", getCall.arguments())) .map(RegularArgument::expression) - .flatMap(TreeUtils.toStreamInstanceOfMapper(StringLiteral.class)); - } - - private static Stream usagesAccessedBySubscription(Symbol symbol, CallExpression call) { - var usages = getForwardUsages(symbol, call); - var parentFromUsages = usages.map(Usage::tree).map(Tree::parent); - var subscriptionsFromUsages = getSubscriptions(parentFromUsages); - return getSubscriptsStringLiteral(subscriptionsFromUsages); + .flatMap(TreeUtils.toOptionalInstanceOfMapper(StringLiteral.class)) + .stream(); } private static Stream getSubscriptions(Stream subscriptions) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/LambdaAssignmentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/LambdaAssignmentCheck.java index d33d273555..f6827c8e31 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/LambdaAssignmentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/LambdaAssignmentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/LdapAuthenticationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/LdapAuthenticationCheck.java index e66b99e080..192b697fe7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/LdapAuthenticationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/LdapAuthenticationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/LineLengthCheck.java b/python-checks/src/main/java/org/sonar/python/checks/LineLengthCheck.java index 958ebcd2f2..63aa019dfd 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/LineLengthCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/LineLengthCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ListIterableFirstElementCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ListIterableFirstElementCheck.java new file mode 100644 index 0000000000..9476c1f795 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/ListIterableFirstElementCheck.java @@ -0,0 +1,98 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.NumericLiteral; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.SubscriptionExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.NumericLiteralImpl; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8519") +public class ListIterableFirstElementCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Replace \"list(...)[0]\" with \"next(iter(...))\" to avoid materializing the entire iterable."; + private static final TypeMatcher IS_LIST = TypeMatchers.isType("list"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.SUBSCRIPTION, ListIterableFirstElementCheck::checkSubscription); + } + + private static void checkSubscription(SubscriptionContext ctx) { + SubscriptionExpression subscriptionExpression = (SubscriptionExpression) ctx.syntaxNode(); + + var subscripts = subscriptionExpression.subscripts(); + if (!subscripts.commas().isEmpty() || subscripts.expressions().size() != 1) { + return; + } + + var subscript = subscripts.expressions().get(0); + if (!(subscript instanceof NumericLiteral numericLiteral)) { + return; + } + if (!isIntegerLiteralSubscript(numericLiteral)) { + return; + } + long indexValue; + try { + indexValue = numericLiteral.valueAsLong(); + } catch (NumberFormatException e) { + return; + } + if (indexValue != 0L) { + return; + } + + if (!(subscriptionExpression.object() instanceof CallExpression listCall)) { + return; + } + + if (!IS_LIST.isTrueFor(listCall.callee(), ctx)) { + return; + } + + if (listCall.arguments().size() != 1 || !(listCall.arguments().get(0) instanceof RegularArgument regularArg)) { + return; + } + + PreciseIssue issue = ctx.addIssue(listCall.callee(), MESSAGE); + + String argText = TreeUtils.treeToString(regularArg.expression(), false); + if (argText != null && !argText.contains("\n")) { + PythonQuickFix quickFix = PythonQuickFix.newQuickFix("Replace with \"next(iter(...))\"", + TextEditUtils.replace(subscriptionExpression, "next(iter(" + argText + "))")); + issue.addQuickFix(quickFix); + } + } + + private static boolean isIntegerLiteralSubscript(NumericLiteral literal) { + if (literal instanceof NumericLiteralImpl impl) { + return impl.numericKind() == NumericLiteralImpl.NumericKind.INT; + } + return false; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/LocalVariableAndParameterNameConventionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/LocalVariableAndParameterNameConventionCheck.java index 7d00d3cce2..24cd555219 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/LocalVariableAndParameterNameConventionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/LocalVariableAndParameterNameConventionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -32,6 +32,8 @@ import org.sonar.plugins.python.api.symbols.Usage; import org.sonar.plugins.python.api.symbols.v2.SymbolV2; import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.AssignmentExpression; import org.sonar.plugins.python.api.tree.AssignmentStatement; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.FunctionDef; @@ -40,6 +42,8 @@ import org.sonar.plugins.python.api.tree.SubscriptionExpression; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.types.v2.PythonType; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.MarimoUtils; import org.sonar.python.semantic.SymbolUtils; import org.sonar.python.tree.TreeUtils; import org.sonar.python.types.v2.TypeCheckBuilder; @@ -91,22 +95,32 @@ private void checkName(SymbolV2 symbol, SubscriptionContext ctx) { return; } if (!pattern.matcher(name).matches()) { - if (isType(symbol)) { + if (hasTypeVariableType(symbol)) { // Type variables generally adhere to class naming conventions rather than regular variable naming conventions return; } + boolean assignedFromType = isAssignedFromType(symbol); symbol.usages().stream() .filter(usage -> USAGES.contains(usage.kind())) .sorted(Comparator.comparingInt(u -> u.tree().firstToken().line())) .limit(1) - .forEach(usage -> raiseIssueForNameAndUsage(ctx, name, usage)); + .forEach(usage -> { + if (assignedFromType && usage.kind() == UsageV2.Kind.ASSIGNMENT_LHS) { + return; + } + raiseIssueForNameAndUsage(ctx, name, usage); + }); } } - private boolean isType(SymbolV2 symbolV2) { + private boolean hasTypeVariableType(SymbolV2 symbolV2) { // TypeV1 and TypeV2 can detect different cases and work complementary to find more issues Symbol symbolV1 = SymbolUtils.symbolV2ToSymbolV1(symbolV2).orElse(null); - return symbolV1 != null && (isExtendingType(symbolV1) || isAssignedFromTyping(symbolV2) || isPythonTypeAClassType(symbolV2)); + return (symbolV1 != null && isExtendingType(symbolV1)) || isPythonTypeAClassType(symbolV2); + } + + private static boolean isAssignedFromType(SymbolV2 symbolV2) { + return isAssignedFromTyping(symbolV2) || isAssignedFromBuiltinType(symbolV2); } private static boolean isExtendingType(Symbol symbol) { @@ -121,18 +135,13 @@ private static boolean isExtendingType(Symbol symbol) { } private static boolean isAssignedFromTyping(SymbolV2 symbol) { - List assignedValues = symbol.usages().stream() - .filter(u -> u.kind() == UsageV2.Kind.ASSIGNMENT_LHS) - .flatMap(usage -> getAssignedValue(usage.tree())) - .toList(); + return assignedValuesOf(symbol) + .map(LocalVariableAndParameterNameConventionCheck::getTypingSymbol) + .anyMatch(assignedSymbol -> assignedSymbol != null && isExtendingType(assignedSymbol)); + } - for (Expression assignedValue : assignedValues) { - Symbol assignedSymbol = getTypingSymbol(assignedValue); - if (assignedSymbol != null && isExtendingType(assignedSymbol)) { - return true; - } - } - return false; + private static boolean isAssignedFromBuiltinType(SymbolV2 symbol) { + return assignedValuesOf(symbol).anyMatch(Expressions::isBuiltinTypeAssignment); } private boolean isPythonTypeAClassType(SymbolV2 symbol) { @@ -140,13 +149,24 @@ private boolean isPythonTypeAClassType(SymbolV2 symbol) { return isDjangoModelTypeCheck.check(type).isTrue(); } + private static Stream assignedValuesOf(SymbolV2 symbol) { + return symbol.usages().stream() + .filter(u -> u.kind() == UsageV2.Kind.ASSIGNMENT_LHS) + .flatMap(usage -> getAssignedValue(usage.tree())); + } + private static Stream getAssignedValue(Tree assignmentName) { - var assignmentStmt = TreeUtils.firstAncestorOfClass(assignmentName, AssignmentStatement.class); - if (assignmentStmt != null) { - return Stream.of(assignmentStmt.assignedValue()); - } else { - return Stream.empty(); + Tree assignment = TreeUtils.firstAncestor(assignmentName, + t -> t.is(Tree.Kind.ASSIGNMENT_STMT, Tree.Kind.ANNOTATED_ASSIGNMENT, Tree.Kind.ASSIGNMENT_EXPRESSION)); + Expression assignedValue = null; + if (assignment instanceof AssignmentStatement assignmentStatement) { + assignedValue = assignmentStatement.assignedValue(); + } else if (assignment instanceof AnnotatedAssignment annotatedAssignment) { + assignedValue = annotatedAssignment.assignedValue(); + } else if (assignment instanceof AssignmentExpression assignmentExpression) { + assignedValue = assignmentExpression.expression(); } + return assignedValue != null ? Stream.of(assignedValue) : Stream.empty(); } private static @Nullable Symbol getTypingSymbol(Expression expr) { @@ -170,7 +190,7 @@ private void raiseIssueForNameAndUsage(SubscriptionContext ctx, String name, Usa if (name.length() <= 1) { return; } - } else if (kind == UsageV2.Kind.PARAMETER && isParameterNameFromOverriddenMethod(usage, name)) { + } else if (kind == UsageV2.Kind.PARAMETER && (isParameterNameFromOverriddenMethod(usage, name) || MarimoUtils.isTreeInMarimoDecoratedFunction(usage.tree(), ctx))) { return; } ctx.addIssue(usage.tree(), String.format(MESSAGE, type, name, format)); diff --git a/python-checks/src/main/java/org/sonar/python/checks/LoggingBestPracticesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/LoggingBestPracticesCheck.java new file mode 100644 index 0000000000..034a002fb0 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/LoggingBestPracticesCheck.java @@ -0,0 +1,148 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Locale; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.BinaryExpression; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.DictionaryLiteral; +import org.sonar.plugins.python.api.tree.DictionaryLiteralElement; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.KeyValuePair; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8554") +public class LoggingBestPracticesCheck extends PythonSubscriptionCheck { + + private static final TypeMatcher LOGGING_CALL_MATCHER = TypeMatchers.any( + TypeMatchers.isType("logging.debug"), + TypeMatchers.isType("logging.info"), + TypeMatchers.isType("logging.warning"), + TypeMatchers.isType("logging.warn"), + TypeMatchers.isType("logging.error"), + TypeMatchers.isType("logging.exception"), + TypeMatchers.isType("logging.critical"), + TypeMatchers.isType("logging.Logger.debug"), + TypeMatchers.isType("logging.Logger.info"), + TypeMatchers.isType("logging.Logger.warning"), + TypeMatchers.isType("logging.Logger.warn"), + TypeMatchers.isType("logging.Logger.error"), + TypeMatchers.isType("logging.Logger.exception"), + TypeMatchers.isType("logging.Logger.critical") + ); + + private static final TypeMatcher DEPRECATED_WARN_MATCHER = TypeMatchers.any( + TypeMatchers.isType("logging.warn"), + TypeMatchers.isType("logging.Logger.warn") + ); + + private static final TypeMatcher STR_FORMAT_MATCHER = TypeMatchers.isType("str.format"); + + private static final Set LOG_RECORD_ATTRIBUTES = new HashSet<>(Arrays.asList( + "name", "msg", "args", "created", "filename", "funcName", "levelname", "levelno", + "lineno", "module", "msecs", "message", "pathname", "process", "processName", + "relativeCreated", "thread", "threadName", "exc_info", "exc_text", "stack_info", + "taskName", "asctime" + )); + + private static final String EAGER_FORMAT_MESSAGE = + "Pass formatting arguments to the logging call instead of pre-formatting the message string."; + private static final String DEPRECATED_WARN_MESSAGE = + "Use \"warning\" instead of the deprecated \"warn\" method."; + private static final String EXTRA_COLLISION_MESSAGE = + "Remove or rename this key; it overrides a built-in LogRecord attribute."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, LoggingBestPracticesCheck::checkLoggingCall); + } + + private static void checkLoggingCall(SubscriptionContext ctx) { + CallExpression call = (CallExpression) ctx.syntaxNode(); + if (!LOGGING_CALL_MATCHER.isTrueFor(call.callee(), ctx)) { + return; + } + + if (DEPRECATED_WARN_MATCHER.isTrueFor(call.callee(), ctx)) { + ctx.addIssue(call.callee(), DEPRECATED_WARN_MESSAGE); + } + + List positionalArgs = call.arguments().stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(RegularArgument.class)) + .filter(arg -> arg.keywordArgument() == null) + .toList(); + + if (!positionalArgs.isEmpty()) { + checkEagerFormatting(ctx, positionalArgs.get(0).expression()); + } + + checkExtraAttributeCollision(ctx, call); + } + + private static void checkEagerFormatting(SubscriptionContext ctx, Expression expr) { + if (expr instanceof StringLiteral literal) { + boolean isFString = literal.stringElements().stream() + .anyMatch(e -> e.prefix().toLowerCase(Locale.ENGLISH).contains("f") && !e.formattedExpressions().isEmpty()); + if (isFString) { + ctx.addIssue(expr, EAGER_FORMAT_MESSAGE); + } + } else if (expr instanceof CallExpression innerCall && STR_FORMAT_MATCHER.isTrueFor(innerCall.callee(), ctx)) { + ctx.addIssue(expr, EAGER_FORMAT_MESSAGE); + } else if (expr.is(Tree.Kind.MODULO) && containsStringLiteral(((BinaryExpression) expr).leftOperand())) { + ctx.addIssue(expr, EAGER_FORMAT_MESSAGE); + } else if (expr.is(Tree.Kind.PLUS) && containsStringLiteral(expr)) { + ctx.addIssue(expr, EAGER_FORMAT_MESSAGE); + } + } + + private static boolean containsStringLiteral(Expression expr) { + if (expr instanceof StringLiteral) { + return true; + } + if (expr.is(Tree.Kind.PLUS)) { + BinaryExpression plus = (BinaryExpression) expr; + return containsStringLiteral(plus.leftOperand()) || containsStringLiteral(plus.rightOperand()); + } + return false; + } + + private static void checkExtraAttributeCollision(SubscriptionContext ctx, CallExpression call) { + RegularArgument extraArg = TreeUtils.argumentByKeyword("extra", call.arguments()); + if (extraArg == null || !(extraArg.expression() instanceof DictionaryLiteral dict)) { + return; + } + for (DictionaryLiteralElement element : dict.elements()) { + if (element instanceof KeyValuePair kvp + && kvp.key() instanceof StringLiteral key + && LOG_RECORD_ATTRIBUTES.contains(key.trimmedQuotesValue())) { + ctx.addIssue(key, EXTRA_COLLISION_MESSAGE); + } + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/LoggingExceptionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/LoggingExceptionCheck.java new file mode 100644 index 0000000000..dc78f5e72c --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/LoggingExceptionCheck.java @@ -0,0 +1,110 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ExceptClause; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.LambdaExpression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8572") +public class LoggingExceptionCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Use \"logging.exception()\" instead."; + + private static final TypeMatcher LOGGING_ERROR_MATCHER = TypeMatchers.any( + TypeMatchers.isType("logging.error"), + TypeMatchers.isType("logging.Logger.error"), + TypeMatchers.isType("logging.LoggerAdapter.error") + ); + + private static final TypeMatcher TRACEBACK_FORMAT_EXC_MATCHER = TypeMatchers.isType("traceback.format_exc"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, LoggingExceptionCheck::checkCall); + } + + private static void checkCall(SubscriptionContext ctx) { + CallExpression callExpr = (CallExpression) ctx.syntaxNode(); + if (!(callExpr.callee() instanceof QualifiedExpression qualifiedCallee)) { + return; + } + if (!LOGGING_ERROR_MATCHER.isTrueFor(qualifiedCallee, ctx)) { + return; + } + ExceptClause exceptClause = findEnclosingExceptClause(callExpr); + if (exceptClause == null) { + return; + } + RegularArgument excInfoArg = TreeUtils.argumentByKeyword("exc_info", callExpr.arguments()); + if (excInfoArg != null) { + if (!Expressions.isTruthy(excInfoArg.expression())) { + return; + } + } else if (!isExceptionLoggedInArgs(callExpr, exceptClause, ctx)) { + return; + } + Name errorName = qualifiedCallee.name(); + ctx.addIssue(errorName, MESSAGE); + } + + @Nullable + private static ExceptClause findEnclosingExceptClause(Tree tree) { + Tree parent = tree.parent(); + while (parent != null) { + if (parent instanceof FunctionDef || parent instanceof LambdaExpression) { + return null; + } + if (parent instanceof ExceptClause exceptClause) { + return exceptClause; + } + parent = parent.parent(); + } + return null; + } + + private static boolean isExceptionLoggedInArgs(CallExpression callExpr, ExceptClause exceptClause, SubscriptionContext ctx) { + SymbolV2 exceptionSymbol = exceptClause.exceptionInstance() instanceof Name name ? name.symbolV2() : null; + return callExpr.arguments().stream().anyMatch(arg -> logsException(arg, exceptionSymbol, ctx)); + } + + private static boolean logsException(Tree tree, @Nullable SymbolV2 exceptionSymbol, SubscriptionContext ctx) { + return matchesExceptionLogging(tree, exceptionSymbol, ctx) + || TreeUtils.hasDescendant(tree, t -> matchesExceptionLogging(t, exceptionSymbol, ctx)); + } + + private static boolean matchesExceptionLogging(Tree tree, @Nullable SymbolV2 exceptionSymbol, SubscriptionContext ctx) { + if (exceptionSymbol != null && tree instanceof Name name && exceptionSymbol.equals(name.symbolV2())) { + return true; + } + return tree instanceof CallExpression call && TRACEBACK_FORMAT_EXC_MATCHER.isTrueFor(call.callee(), ctx); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/LongIntegerWithLowercaseSuffixUsageCheck.java b/python-checks/src/main/java/org/sonar/python/checks/LongIntegerWithLowercaseSuffixUsageCheck.java index 36bbe68952..0d678c1fc2 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/LongIntegerWithLowercaseSuffixUsageCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/LongIntegerWithLowercaseSuffixUsageCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/LoopExecutingAtMostOnceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/LoopExecutingAtMostOnceCheck.java index 098a0da852..d0eae3db37 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/LoopExecutingAtMostOnceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/LoopExecutingAtMostOnceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -29,8 +29,6 @@ import org.sonar.plugins.python.api.cfg.ControlFlowGraph; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.tree.FileInput; -import org.sonar.plugins.python.api.tree.FunctionDef; import org.sonar.plugins.python.api.tree.Token; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.Tree.Kind; @@ -43,10 +41,10 @@ public class LoopExecutingAtMostOnceCheck extends PythonSubscriptionCheck { @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Kind.FUNCDEF, ctx -> - checkCfg(ControlFlowGraph.build((FunctionDef) ctx.syntaxNode(), ctx.pythonFile()), ctx) + checkCfg(ctx.cfg(ctx.syntaxNode()), ctx) ); context.registerSyntaxNodeConsumer(Kind.FILE_INPUT, ctx -> - checkCfg(ControlFlowGraph.build((FileInput) ctx.syntaxNode(), ctx.pythonFile()), ctx) + checkCfg(ctx.cfg(ctx.syntaxNode()), ctx) ); } diff --git a/python-checks/src/main/java/org/sonar/python/checks/LoopOverDictKeyValuesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/LoopOverDictKeyValuesCheck.java index 6151ed1d44..69253e72d6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/LoopOverDictKeyValuesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/LoopOverDictKeyValuesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/MandatoryFunctionParameterTypeHintCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MandatoryFunctionParameterTypeHintCheck.java index facec6d695..cf9879bfe0 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/MandatoryFunctionParameterTypeHintCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/MandatoryFunctionParameterTypeHintCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/MandatoryFunctionReturnTypeHintCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MandatoryFunctionReturnTypeHintCheck.java index 72a749c4e1..590f30fa27 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/MandatoryFunctionReturnTypeHintCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/MandatoryFunctionReturnTypeHintCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -17,11 +17,10 @@ package org.sonar.python.checks; import java.util.ArrayList; +import java.util.HashSet; import java.util.List; -import java.util.Objects; import java.util.Optional; import java.util.Set; -import java.util.stream.Collectors; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; @@ -34,22 +33,23 @@ import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.YieldStatement; import org.sonar.plugins.python.api.types.BuiltinTypes; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.quickfix.TextEditUtils; import org.sonar.python.tree.FunctionDefImpl; -import org.sonar.python.types.InferredTypes; @Rule(key = "S6538") public class MandatoryFunctionReturnTypeHintCheck extends PythonSubscriptionCheck { public static final String MESSAGE = "Add a return type hint to this function declaration."; public static final String CONSTRUCTOR_MESSAGE = "Annotate the return type of this constructor with `None`."; - private static final List SUPPORTED_TYPES = List.of( - BuiltinTypes.STR, - BuiltinTypes.NONE_TYPE, - BuiltinTypes.BOOL, - BuiltinTypes.COMPLEX, - BuiltinTypes.FLOAT, - BuiltinTypes.INT); + private static final List SUPPORTED_TYPES = List.of( + new SupportedReturnType(TypeMatchers.isObjectOfType("builtins.str"), BuiltinTypes.STR), + new SupportedReturnType(TypeMatchers.isObjectOfType("NoneType"), "None"), + new SupportedReturnType(TypeMatchers.isObjectOfType("builtins.bool"), BuiltinTypes.BOOL), + new SupportedReturnType(TypeMatchers.isObjectOfType("builtins.complex"), BuiltinTypes.COMPLEX), + new SupportedReturnType(TypeMatchers.isObjectOfType("builtins.float"), BuiltinTypes.FLOAT), + new SupportedReturnType(TypeMatchers.isObjectOfType("builtins.int"), BuiltinTypes.INT)); @Override public void initialize(Context context) { @@ -78,7 +78,7 @@ private static void raiseIssueForReturnType(SubscriptionContext ctx, Name functi ReturnStatementVisitor returnStatementVisitor = new ReturnStatementVisitor(); functionDef.body().accept(returnStatementVisitor); if (!returnStatementVisitor.returnStatements.isEmpty()) { - addQuickFixForReturnType(issue, functionDef, returnStatementVisitor.returnStatements); + addQuickFixForReturnType(ctx, issue, functionDef, returnStatementVisitor.returnStatements); } else if (returnStatementVisitor.yieldStatements.isEmpty()) { addQuickFixForNoneType(issue, functionDef); } @@ -91,26 +91,39 @@ private static void addQuickFixForNoneType(PreciseIssue issue, FunctionDef funct issue.addQuickFix(quickFix); } - private static void addQuickFixForReturnType(PreciseIssue issue, FunctionDef functionDef, List statements) { - Set returnTypes = statements.stream() - .flatMap(stmts -> stmts.expressions().stream()) - .map(Expression::type) - .map(InferredTypes::typeName) - .filter(Objects::nonNull) - .collect(Collectors.toSet()); + private static void addQuickFixForReturnType(SubscriptionContext ctx, PreciseIssue issue, FunctionDef functionDef, List statements) { + Set returnTypes = collectSupportedReturnTypeAnnotations(statements, ctx); if (returnTypes.size() == 1) { - String typeName = returnTypes.stream().iterator().next(); - if (SUPPORTED_TYPES.contains(typeName)) { - PythonQuickFix quickFix = PythonQuickFix.newQuickFix(MandatoryFunctionReturnTypeHintCheck.MESSAGE) - .addTextEdit(TextEditUtils.insertAfter(functionDef.rightPar(), String.format(" -> %s", fixTypeName(typeName)))) - .build(); - issue.addQuickFix(quickFix); + String annotation = returnTypes.iterator().next(); + PythonQuickFix quickFix = PythonQuickFix.newQuickFix(MandatoryFunctionReturnTypeHintCheck.MESSAGE) + .addTextEdit(TextEditUtils.insertAfter(functionDef.rightPar(), String.format(" -> %s", annotation))) + .build(); + issue.addQuickFix(quickFix); + } + } + + private static Set collectSupportedReturnTypeAnnotations(List statements, SubscriptionContext ctx) { + Set returnTypes = new HashSet<>(); + for (ReturnStatement stmt : statements) { + for (Expression expression : stmt.expressions()) { + Optional annotation = supportedReturnTypeAnnotation(expression, ctx); + if (annotation.isEmpty()) { + return Set.of(); + } + returnTypes.add(annotation.get()); } } + return returnTypes; + } + + private static Optional supportedReturnTypeAnnotation(Expression expression, SubscriptionContext ctx) { + return SUPPORTED_TYPES.stream() + .filter(supportedType -> supportedType.matcher().isTrueFor(expression, ctx)) + .map(SupportedReturnType::annotation) + .findFirst(); } - private static String fixTypeName(String typeName) { - return typeName.equals(BuiltinTypes.NONE_TYPE) ? "None" : typeName; + private record SupportedReturnType(TypeMatcher matcher, String annotation) { } private static class ReturnStatementVisitor extends BaseTreeVisitor { diff --git a/python-checks/src/main/java/org/sonar/python/checks/MembershipTestSupportCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MembershipTestSupportCheck.java index 07a48e4efc..8c9878d8f6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/MembershipTestSupportCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/MembershipTestSupportCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/MethodNameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MethodNameCheck.java index a0c7f1cd11..c9a5b77c5d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/MethodNameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/MethodNameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,6 +16,7 @@ */ package org.sonar.python.checks; +import java.util.Set; import org.sonar.check.Rule; import org.sonar.plugins.python.api.tree.FunctionDef; @@ -26,6 +27,8 @@ public class MethodNameCheck extends AbstractFunctionNameCheck { public static final String CHECK_KEY = "S100"; + private static final Set WHITELIST = Set.of("setUp", "tearDown", "setUpClass", "tearDownClass", "setUpTestData"); + @Override public String typeName() { return "method"; @@ -33,6 +36,8 @@ public String typeName() { @Override public boolean shouldCheckFunctionDeclaration(FunctionDef pyFunctionDefTree) { - return pyFunctionDefTree.isMethodDefinition() && !classHasInheritance(getParentClassDef(pyFunctionDefTree)); + return pyFunctionDefTree.isMethodDefinition() + && !classHasInheritance(getParentClassDef(pyFunctionDefTree)) + && !WHITELIST.contains(pyFunctionDefTree.name().name()); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/MethodShouldBeStaticCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MethodShouldBeStaticCheck.java index 93710c836b..37fc66e8d8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/MethodShouldBeStaticCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/MethodShouldBeStaticCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/MissingDocstringCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MissingDocstringCheck.java index 85f499bfc2..aec7483191 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/MissingDocstringCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/MissingDocstringCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/MissingHyperParameterCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MissingHyperParameterCheck.java index 9ec7f34ad7..c0fd33c2d1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/MissingHyperParameterCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/MissingHyperParameterCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/MissingNewlineAtEndOfFileCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MissingNewlineAtEndOfFileCheck.java index 3b870169e0..d10a82336b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/MissingNewlineAtEndOfFileCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/MissingNewlineAtEndOfFileCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ModifiedParameterValueCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ModifiedParameterValueCheck.java index e2795b6d90..c380e7de1d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ModifiedParameterValueCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ModifiedParameterValueCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ModuleNameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ModuleNameCheck.java index 3a2970d6dd..ef33d749c4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ModuleNameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ModuleNameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/MultipleInheritanceMROConflictCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MultipleInheritanceMROConflictCheck.java new file mode 100644 index 0000000000..ef729fe4dc --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/MultipleInheritanceMROConflictCheck.java @@ -0,0 +1,178 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import javax.annotation.CheckForNull; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.ArgList; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.ClassType; +import org.sonar.plugins.python.api.types.v2.PythonType; +import org.sonar.plugins.python.api.types.v2.TypeWrapper; + +@Rule(key = "S8511") +public class MultipleInheritanceMROConflictCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Reorder or remove base classes to fix this MRO conflict."; + private static final String SECONDARY_MESSAGE = "This base class is an ancestor of another listed base class appearing after it."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, MultipleInheritanceMROConflictCheck::checkClassDef); + } + + private static void checkClassDef(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + ArgList argList = classDef.args(); + if (argList == null) { + return; + } + + List bases = collectPositionalBases(argList); + if (bases.size() < 2) { + return; + } + + List types = new ArrayList<>(); + for (Expression base : bases) { + types.add(resolveClassType(base)); + } + + int conflictIndex = findAncestorConflictIndex(types); + if (hasMroConflict(types, conflictIndex)) { + PreciseIssue issue = ctx.addIssue(classDef.name(), MESSAGE); + if (conflictIndex >= 0) { + issue.secondary(bases.get(conflictIndex), SECONDARY_MESSAGE); + } + } + } + + private static List collectPositionalBases(ArgList argList) { + List bases = new ArrayList<>(); + for (Argument argument : argList.arguments()) { + if (argument instanceof RegularArgument regularArgument && regularArgument.keywordArgument() == null) { + bases.add(regularArgument.expression()); + } + } + return bases; + } + + /** + * Detects an MRO conflict: either via C3 when every base is fully resolved, or otherwise only + * when {@link #findAncestorConflictIndex} finds an earlier base that is a strict superclass of a + * later base. Both paths use a runtime-faithful view of built-in containers — see + * {@link ClassType#wouldHaveValidMro(List)}. + */ + private static boolean hasMroConflict(List types, int conflictIndex) { + if (isFullyResolved(types)) { + return !ClassType.wouldHaveValidMro(types); + } + return conflictIndex >= 0; + } + + /** + * Returns {@code true} if every base class is fully resolved (non-null, with a fully known type + * hierarchy). Only when this is true can we run the complete C3 algorithm safely. + */ + private static boolean isFullyResolved(List types) { + for (ClassType type : types) { + if (type == null || type.hasUnresolvedHierarchy()) { + return false; + } + } + return true; + } + + /** + * Returns the index {@code i} of the first base class that is an ancestor of some later base + * class at index {@code j > i}, or {@code -1} if no such pair exists. Paths from any later base + * that pass through a virtual-ABC-subclassing builtin are cut off, so typeshed-only ABC edges + * (e.g. {@code dict → MutableMapping}) are not treated as real ancestry — see + * {@link #isOrExtendsClassAtRuntime(ClassType, ClassType)}. + */ + private static int findAncestorConflictIndex(List types) { + for (int i = 0; i < types.size() - 1; i++) { + if (laterBaseExtendsEarlier(types, i)) { + return i; + } + } + return -1; + } + + private static boolean laterBaseExtendsEarlier(List types, int i) { + ClassType typeI = types.get(i); + if (typeI == null) { + return false; + } + for (int j = i + 1; j < types.size(); j++) { + ClassType typeJ = types.get(j); + if (typeJ != null && isOrExtendsClassAtRuntime(typeJ, typeI)) { + return true; + } + } + return false; + } + + /** + * Returns {@code true} if {@code ancestor} appears in {@code candidate}'s runtime type hierarchy. + * Traversal stops at virtual-ABC-subclassing builtins so their typeshed-only ABC parents are not + * reachable; see {@link ClassType#wouldHaveValidMro(List)}. Uses reference equality + * since {@link ClassType} instances are canonical within a single analysis. + */ + private static boolean isOrExtendsClassAtRuntime(ClassType candidate, ClassType ancestor) { + Set visited = new HashSet<>(); + Deque queue = new ArrayDeque<>(); + queue.add(candidate); + while (!queue.isEmpty()) { + PythonType current = queue.poll(); + if (!visited.add(current)) { + continue; + } + if (current == ancestor) { + return true; + } + if (current instanceof ClassType ct && !ct.isVirtualAbcSubclassingBuiltin()) { + enqueueDirectSuperclasses(ct, queue); + } + } + return false; + } + + private static void enqueueDirectSuperclasses(ClassType ct, Deque queue) { + for (TypeWrapper sw : ct.superClasses()) { + queue.add(sw.type()); + } + } + + @CheckForNull + private static ClassType resolveClassType(Expression expression) { + PythonType type = expression.typeV2(); + return (type instanceof ClassType classType) ? classType : null; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/MutableDefaultValueCheck.java b/python-checks/src/main/java/org/sonar/python/checks/MutableDefaultValueCheck.java new file mode 100644 index 0000000000..c521dfb3cb --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/MutableDefaultValueCheck.java @@ -0,0 +1,111 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.List; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8508") +public class MutableDefaultValueCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Replace this mutable value with an immutable default to avoid shared state."; + + private static final TypeMatcher IS_DICT_TYPE = TypeMatchers.isType("builtins.dict"); + private static final TypeMatcher IS_CONTEXT_VAR = TypeMatchers.isType("contextvars.ContextVar"); + private static final TypeMatcher IS_MUTABLE_CONSTRUCTOR = TypeMatchers.any( + TypeMatchers.isType("builtins.list"), + TypeMatchers.isType("builtins.dict"), + TypeMatchers.isType("builtins.set"), + TypeMatchers.isType("builtins.bytearray") + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, MutableDefaultValueCheck::checkCall); + } + + private static void checkCall(SubscriptionContext ctx) { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + Expression callee = callExpression.callee(); + if (isDictFromkeys(callee, ctx)) { + checkDictFromkeys(ctx, callExpression); + } else if (IS_CONTEXT_VAR.isTrueFor(callee, ctx)) { + checkContextVar(ctx, callExpression); + } + } + + private static boolean isDictFromkeys(Expression callee, SubscriptionContext ctx) { + if (!(callee instanceof QualifiedExpression qualifiedExpr)) { + return false; + } + return "fromkeys".equals(qualifiedExpr.name().name()) + && IS_DICT_TYPE.isTrueFor(qualifiedExpr.qualifier(), ctx); + } + + private static void checkDictFromkeys(SubscriptionContext ctx, CallExpression callExpression) { + List arguments = callExpression.arguments(); + if (arguments.size() < 2) { + return; + } + Argument secondArg = arguments.get(1); + if (secondArg instanceof RegularArgument regularArg && regularArg.keywordArgument() == null) { + checkAndReportIfMutable(regularArg.expression(), ctx); + } + } + + private static void checkContextVar(SubscriptionContext ctx, CallExpression callExpression) { + RegularArgument defaultArg = TreeUtils.argumentByKeyword("default", callExpression.arguments()); + if (defaultArg != null) { + checkAndReportIfMutable(defaultArg.expression(), ctx); + } + } + + private static void checkAndReportIfMutable(Expression value, SubscriptionContext ctx) { + if (isMutableValue(value, ctx)) { + ctx.addIssue(value, MESSAGE); + } + } + + private static boolean isMutableValue(Expression expression, SubscriptionContext ctx) { + if (expression.is(Tree.Kind.LIST_LITERAL) + || expression.is(Tree.Kind.DICTIONARY_LITERAL) + || expression.is(Tree.Kind.SET_LITERAL)) { + return true; + } + if (expression instanceof CallExpression callExpr) { + return IS_MUTABLE_CONSTRUCTOR.isTrueFor(callExpr.callee(), ctx); + } + if (expression instanceof Name name) { + Set values = ctx.valuesAtLocation(name); + return !values.isEmpty() && values.stream().allMatch(v -> isMutableValue(v, ctx)); + } + return false; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/NeedlessPassCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NeedlessPassCheck.java index 1f7d272fe8..01e52840a4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NeedlessPassCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NeedlessPassCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NestedCollectionsCreationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NestedCollectionsCreationCheck.java index 0dfbc94baf..555437d673 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NestedCollectionsCreationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NestedCollectionsCreationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NestedConditionalExpressionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NestedConditionalExpressionCheck.java index c23d88598d..c0418b382d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NestedConditionalExpressionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NestedConditionalExpressionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NestedControlFlowDepthCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NestedControlFlowDepthCheck.java index 4183f97ee2..a2b39f3c28 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NestedControlFlowDepthCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NestedControlFlowDepthCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NestedLoopVariableReuseCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NestedLoopVariableReuseCheck.java new file mode 100644 index 0000000000..73783ca8b2 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/NestedLoopVariableReuseCheck.java @@ -0,0 +1,117 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ForStatement; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.Tuple; + +@Rule(key = "S8510") +public class NestedLoopVariableReuseCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Rename this loop variable; it shadows the outer loop variable \"%s\"."; + private static final String SECONDARY_MESSAGE = "Outer loop variable."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FOR_STMT, NestedLoopVariableReuseCheck::checkForStatement); + } + + private static void checkForStatement(SubscriptionContext ctx) { + ForStatement forStatement = (ForStatement) ctx.syntaxNode(); + List innerVarNames = extractLoopVarNames(forStatement); + if (innerVarNames.isEmpty()) { + return; + } + Map> shadowedOuterNames = collectShadowedNames(forStatement, innerVarNames); + reportIssues(ctx, shadowedOuterNames); + } + + private static Map> collectShadowedNames(ForStatement forStatement, List innerVarNames) { + Map> shadowedOuterNames = new LinkedHashMap<>(); + for (Name innerName : innerVarNames) { + shadowedOuterNames.put(innerName, new ArrayList<>()); + } + Tree current = forStatement.parent(); + while (current != null) { + if (current.is(Tree.Kind.FUNCDEF, Tree.Kind.CLASSDEF, Tree.Kind.LAMBDA, + Tree.Kind.LIST_COMPREHENSION, Tree.Kind.SET_COMPREHENSION, + Tree.Kind.DICT_COMPREHENSION, Tree.Kind.GENERATOR_EXPR)) { + break; + } + if (current.is(Tree.Kind.FOR_STMT)) { + collectMatchingNames((ForStatement) current, innerVarNames, shadowedOuterNames); + } + current = current.parent(); + } + return shadowedOuterNames; + } + + private static void collectMatchingNames(ForStatement outerLoop, List innerVarNames, Map> shadowedOuterNames) { + List outerVarNames = extractLoopVarNames(outerLoop); + for (Name innerName : innerVarNames) { + for (Name outerName : outerVarNames) { + if (innerName.name().equals(outerName.name())) { + shadowedOuterNames.get(innerName).add(outerName); + } + } + } + } + + private static void reportIssues(SubscriptionContext ctx, Map> shadowedOuterNames) { + for (Map.Entry> entry : shadowedOuterNames.entrySet()) { + Name innerName = entry.getKey(); + List outerNames = entry.getValue(); + if (!outerNames.isEmpty()) { + var issue = ctx.addIssue(innerName, String.format(MESSAGE, innerName.name())); + for (Name outerName : outerNames) { + issue.secondary(outerName, SECONDARY_MESSAGE); + } + } + } + } + + private static List extractLoopVarNames(ForStatement forStatement) { + List names = new ArrayList<>(); + for (Expression expr : forStatement.expressions()) { + collectNames(expr, names); + } + return names; + } + + private static void collectNames(Expression expr, List names) { + if (expr.is(Tree.Kind.NAME)) { + Name name = (Name) expr; + if (!name.name().startsWith("_")) { + names.add(name); + } + } else if (expr.is(Tree.Kind.TUPLE)) { + for (Expression element : ((Tuple) expr).elements()) { + collectNames(element, names); + } + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/NewStyleClassCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NewStyleClassCheck.java index 7a61f56643..401fec4c4e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NewStyleClassCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NewStyleClassCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NoPersonReferenceInTodoCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NoPersonReferenceInTodoCheck.java index 8ab030dba6..4eecdf3f8d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NoPersonReferenceInTodoCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NoPersonReferenceInTodoCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NoQaCommentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NoQaCommentCheck.java index acff684331..ea1b0bb25d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NoQaCommentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NoQaCommentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -26,16 +26,25 @@ @Rule(key = "S1309") public class NoQaCommentCheck extends PythonSubscriptionCheck { - private static final String MESSAGE = "Is #noqa used to exclude false-positive or to hide real quality flaw?"; + private static final String NOQA_MESSAGE = "Is 'noqa' used to exclude false-positive or to hide real quality flaw?"; + private static final String NOSEC_MESSAGE = "Is 'nosec' used to exclude false-positive or to hide real security issue?"; @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.TOKEN, ctx -> { Token token = (Token) ctx.syntaxNode(); for (Trivia trivia : token.trivia()) { - String commentLine = trivia.token().value(); - if (NoSonarInfoParser.isValidNoQa(commentLine)) { - ctx.addIssue(trivia.token(), MESSAGE); + for (String comment : NoSonarInfoParser.splitInlineComments(trivia.token().value())) { + String message = null; + if (NoSonarInfoParser.isValidNoQa(comment)) { + message = NOQA_MESSAGE; + } else if (NoSonarInfoParser.isValidNoSec(comment)) { + message = NOSEC_MESSAGE; + } + if (message != null) { + ctx.addIssue(trivia.token(), message); + break; + } } } }); diff --git a/python-checks/src/main/java/org/sonar/python/checks/NoReRaiseInExitCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NoReRaiseInExitCheck.java index 8ac34f89fb..ef836d4eac 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NoReRaiseInExitCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NoReRaiseInExitCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NoSonarCommentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NoSonarCommentCheck.java index ea6c39810c..fbf497cec7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NoSonarCommentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NoSonarCommentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NoSonarCommentFormatCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NoSonarCommentFormatCheck.java index cfaa17af1a..d9aeef14cd 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NoSonarCommentFormatCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NoSonarCommentFormatCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NonCallableCalled.java b/python-checks/src/main/java/org/sonar/python/checks/NonCallableCalled.java index bd70598fce..6ed8d01519 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NonCallableCalled.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NonCallableCalled.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NonCallableCalledCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NonCallableCalledCheck.java index 96d5d67ade..2785056db4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NonCallableCalledCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NonCallableCalledCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NonSingletonTfVariableCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NonSingletonTfVariableCheck.java index 530e939c22..deba6732ac 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NonSingletonTfVariableCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NonSingletonTfVariableCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NonStringInAllPropertyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NonStringInAllPropertyCheck.java index fdcb8514ba..9872b384c4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NonStringInAllPropertyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NonStringInAllPropertyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NotImplementedBooleanContextCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NotImplementedBooleanContextCheck.java index 1d2e364dd3..962db61458 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NotImplementedBooleanContextCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NotImplementedBooleanContextCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NotImplementedErrorInOperatorMethodsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NotImplementedErrorInOperatorMethodsCheck.java index c2c2e42160..1780994b25 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NotImplementedErrorInOperatorMethodsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NotImplementedErrorInOperatorMethodsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NumpyIsNanCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NumpyIsNanCheck.java index 2702442adf..e1cc36aafa 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NumpyIsNanCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NumpyIsNanCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NumpyListOverGeneratorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NumpyListOverGeneratorCheck.java index 1957848ddb..e76f8c005e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NumpyListOverGeneratorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NumpyListOverGeneratorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -22,38 +22,37 @@ import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.Argument; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; -import org.sonar.plugins.python.api.tree.HasSymbol; import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.cfg.fixpoint.ReachingDefinitionsAnalysis; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.tree.TreeUtils; @Rule(key = "S6714") public class NumpyListOverGeneratorCheck extends PythonSubscriptionCheck { public static final String MESSAGE = "Pass a list to \"np.array\" instead of passing a generator."; - private ReachingDefinitionsAnalysis reachingDefinitionsAnalysis; + + private static final TypeMatcher IS_NUMPY_ARRAY = TypeMatchers.withFQN("numpy.array"); + private static final TypeMatcher IS_OBJECT_TYPE = TypeMatchers.isType("builtins.object"); @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> reachingDefinitionsAnalysis = new ReachingDefinitionsAnalysis((ctx.pythonFile()))); - context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, this::checkNumpyArrayCall); + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, NumpyListOverGeneratorCheck::checkNumpyArrayCall); } - private void checkNumpyArrayCall(SubscriptionContext ctx) { + private static void checkNumpyArrayCall(SubscriptionContext ctx) { CallExpression call = (CallExpression) ctx.syntaxNode(); - Optional.ofNullable(call.calleeSymbol()) - .map(Symbol::fullyQualifiedName) - .filter("numpy.array"::equals) - .ifPresent(fqn -> checkGeneratorCallee(call, ctx)); + if (IS_NUMPY_ARRAY.isTrueFor(call.callee(), ctx)) { + checkGeneratorCallee(call, ctx); + } } - private void checkGeneratorCallee(CallExpression call, SubscriptionContext ctx) { + private static void checkGeneratorCallee(CallExpression call, SubscriptionContext ctx) { List argList = call.arguments(); if (argList.isEmpty()) { return; @@ -63,26 +62,21 @@ private void checkGeneratorCallee(CallExpression call, SubscriptionContext ctx) .filter(arg -> arg.is(Tree.Kind.REGULAR_ARGUMENT)) .map(RegularArgument.class::cast) .map(RegularArgument::expression) - .filter(regArg -> (regArg.is(Tree.Kind.GENERATOR_EXPR) || this.isNamedGeneratorExpression(regArg))) + .filter(regArg -> (regArg.is(Tree.Kind.GENERATOR_EXPR) || isNamedGeneratorExpression(regArg, ctx))) .isEmpty()) { return; } - if (Optional.ofNullable(TreeUtils.nthArgumentOrKeyword(1, "dtype", argList)) - .filter(regArg -> regArg.expression().is(Tree.Kind.NAME)) - .map(regArg -> (Name) regArg.expression()) - .map(HasSymbol::symbol) - .map(Symbol::fullyQualifiedName) - .filter("object"::equals) - .isEmpty()) { + RegularArgument dtypeArg = TreeUtils.nthArgumentOrKeyword(1, "dtype", argList); + if (dtypeArg == null || !IS_OBJECT_TYPE.isTrueFor(dtypeArg.expression(), ctx)) { ctx.addIssue(call, MESSAGE); } } - private boolean isNamedGeneratorExpression(Expression expression) { + private static boolean isNamedGeneratorExpression(Expression expression, SubscriptionContext ctx) { return Optional.of(expression) .flatMap(TreeUtils.toOptionalInstanceOfMapper(Name.class)) - .map(name -> this.reachingDefinitionsAnalysis.valuesAtLocation(name)) + .map(ctx::valuesAtLocation) .filter(NumpyListOverGeneratorCheck::checkSetProperties) .isPresent(); } diff --git a/python-checks/src/main/java/org/sonar/python/checks/NumpyRandomStateCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NumpyRandomStateCheck.java index 291b112f89..f6aca5eeb0 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NumpyRandomStateCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NumpyRandomStateCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NumpyWeekMaskValidationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NumpyWeekMaskValidationCheck.java index b71fedaff7..27f1241b92 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NumpyWeekMaskValidationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NumpyWeekMaskValidationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/NumpyWhereOneConditionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/NumpyWhereOneConditionCheck.java index 1302e8e6c9..969751ff4c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/NumpyWhereOneConditionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/NumpyWhereOneConditionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -22,19 +22,22 @@ import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.quickfix.PythonQuickFix; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.Argument; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.QualifiedExpression; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.quickfix.TextEditUtils; @Rule(key = "S6729") public class NumpyWhereOneConditionCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Use \"np.nonzero\" when only the condition parameter is provided to \"np.where\"."; + // numpy.where has no stubs, so the type resolves as UnresolvedImportType. Use withFQN to match on the FQN directly. + private static final TypeMatcher NUMPY_WHERE = TypeMatchers.withFQN("numpy.where"); @Override public void initialize(Context context) { @@ -43,15 +46,11 @@ public void initialize(Context context) { private static void checkNumpyWhereCall(SubscriptionContext ctx) { CallExpression ce = (CallExpression) ctx.syntaxNode(); - Symbol symbol = ce.calleeSymbol(); - Optional.ofNullable(symbol) - .map(Symbol::fullyQualifiedName) - .filter("numpy.where"::equals) - .filter(fqn -> hasOneParameter(ce)) - .ifPresent(fqn -> { - PreciseIssue issue = ctx.addIssue(ce, MESSAGE); - addQuickFix(ce, issue); - }); + if (!NUMPY_WHERE.isTrueFor(ce.callee(), ctx) || !hasOneParameter(ce)) { + return; + } + PreciseIssue issue = ctx.addIssue(ce, MESSAGE); + addQuickFix(ce, issue); } private static void addQuickFix(CallExpression ce, PreciseIssue issue) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/OneStatementPerLineCheck.java b/python-checks/src/main/java/org/sonar/python/checks/OneStatementPerLineCheck.java index ce3b125715..631c8c1d8f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/OneStatementPerLineCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/OneStatementPerLineCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/OpenSourceCheckList.java b/python-checks/src/main/java/org/sonar/python/checks/OpenSourceCheckList.java index 8a27548ad9..91dce4aa6e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/OpenSourceCheckList.java +++ b/python-checks/src/main/java/org/sonar/python/checks/OpenSourceCheckList.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -31,7 +31,6 @@ import org.sonar.python.checks.cdk.S3BucketBlockPublicAccessCheck; import org.sonar.python.checks.cdk.S3BucketGrantedAccessCheck; import org.sonar.python.checks.cdk.S3BucketHTTPCommunicationCheck; -import org.sonar.python.checks.cdk.S3BucketServerEncryptionCheck; import org.sonar.python.checks.cdk.S3BucketVersioningCheck; import org.sonar.python.checks.cdk.UnencryptedEbsVolumeCheck; import org.sonar.python.checks.cdk.UnencryptedSageMakerNotebookCheck; @@ -42,15 +41,11 @@ import org.sonar.python.checks.django.DjangoModelStrMethodCheck; import org.sonar.python.checks.django.DjangoModelStringFieldCheck; import org.sonar.python.checks.hotspots.ClearTextProtocolsCheck; -import org.sonar.python.checks.hotspots.CommandLineArgsCheck; import org.sonar.python.checks.hotspots.CorsCheck; import org.sonar.python.checks.hotspots.CsrfDisabledCheck; -import org.sonar.python.checks.hotspots.DataEncryptionCheck; import org.sonar.python.checks.hotspots.DebugModeCheck; import org.sonar.python.checks.hotspots.DisabledHtmlAutoEscapeCheck; import org.sonar.python.checks.hotspots.DisabledHtmlAutoEscapeLegacyCheck; -import org.sonar.python.checks.hotspots.DynamicCodeExecutionCheck; -import org.sonar.python.checks.hotspots.EmailSendingCheck; import org.sonar.python.checks.hotspots.ExpandingArchiveCheck; import org.sonar.python.checks.hotspots.FastHashingOrPlainTextCheck; import org.sonar.python.checks.hotspots.GraphQLIntrospectionCheck; @@ -58,16 +53,12 @@ import org.sonar.python.checks.hotspots.HardCodedCredentialsEntropyCheck; import org.sonar.python.checks.hotspots.HashingDataCheck; import org.sonar.python.checks.hotspots.HttpOnlyCookieCheck; -import org.sonar.python.checks.hotspots.LoggersConfigurationCheck; import org.sonar.python.checks.hotspots.NonStandardCryptographicAlgorithmCheck; -import org.sonar.python.checks.hotspots.OsExecCheck; import org.sonar.python.checks.hotspots.ProcessSignallingCheck; import org.sonar.python.checks.hotspots.PseudoRandomCheck; import org.sonar.python.checks.hotspots.PubliclyWritableDirectoriesCheck; -import org.sonar.python.checks.hotspots.RegexCheck; import org.sonar.python.checks.hotspots.SQLQueriesCheck; import org.sonar.python.checks.hotspots.SecureCookieCheck; -import org.sonar.python.checks.hotspots.StandardInputCheck; import org.sonar.python.checks.hotspots.StrongCryptographicKeysCheck; import org.sonar.python.checks.hotspots.UnsafeHttpMethodsCheck; import org.sonar.python.checks.hotspots.UnverifiedHostnameCheck; @@ -95,22 +86,58 @@ import org.sonar.python.checks.regex.SingleCharacterAlternationCheck; import org.sonar.python.checks.regex.StringReplaceCheck; import org.sonar.python.checks.regex.SuperfluousCurlyBraceCheck; +import org.sonar.python.checks.regex.SuperLinearRegexCheck; import org.sonar.python.checks.regex.UnquantifiedNonCapturingGroupCheck; import org.sonar.python.checks.regex.UnusedGroupNamesCheck; import org.sonar.python.checks.regex.VerboseRegexCheck; import org.sonar.python.checks.tests.AssertAfterRaiseCheck; +import org.sonar.python.checks.tests.AssertionInTryCheck; import org.sonar.python.checks.tests.AssertOnDissimilarTypesCheck; import org.sonar.python.checks.tests.AssertOnTupleLiteralCheck; +import org.sonar.python.checks.tests.AssertionArgumentOrderCheck; +import org.sonar.python.checks.tests.CompositeAssertionCheck; import org.sonar.python.checks.tests.DedicatedAssertionCheck; +import org.sonar.python.checks.tests.DedicatedExceptionAssertionCheck; +import org.sonar.python.checks.tests.DeprecatedYieldFixtureCheck; +import org.sonar.python.checks.tests.DuplicateParametrizeCasesCheck; +import org.sonar.python.checks.tests.EmptyParametrizeValuesCheck; +import org.sonar.python.checks.tests.FixtureParamDependenciesCheck; +import org.sonar.python.checks.tests.GroupSimilarTestsParameterizedCheck; +import org.sonar.python.checks.tests.IdenticalAssertionArgumentsCheck; import org.sonar.python.checks.tests.ImplicitlySkippedTestCheck; +import org.sonar.python.checks.tests.IntentionalTestFailureMessageCheck; +import org.sonar.python.checks.tests.MisspelledMockAssertionCheck; +import org.sonar.python.checks.tests.MockPatchLambdaReturnValueCheck; +import org.sonar.python.checks.tests.MocksShouldUseAutospecCheck; import org.sonar.python.checks.tests.NotDiscoverableTestMethodCheck; +import org.sonar.python.checks.tests.PytestAutouseParametrizedFixtureCheck; +import org.sonar.python.checks.tests.PytestDecoratorParenthesesCheck; +import org.sonar.python.checks.tests.PytestDefaultFixtureScopeCheck; +import org.sonar.python.checks.tests.PytestFixtureMultipleYieldCheck; +import org.sonar.python.checks.tests.PytestFixturePositionalArgsCheck; +import org.sonar.python.checks.tests.PytestFixtureYieldTeardownCheck; +import org.sonar.python.checks.tests.PytestModuleImportCheck; +import org.sonar.python.checks.tests.PytestParameterDefaultValueCheck; +import org.sonar.python.checks.tests.PytestPluginsConftestCheck; +import org.sonar.python.checks.tests.PytestRaisesContextManagerCheck; +import org.sonar.python.checks.tests.PytestUselessYieldFixtureCheck; +import org.sonar.python.checks.tests.SingleInvocationRuntimeExceptionCheck; +import org.sonar.python.checks.tests.SingleInvocationWarningCheck; import org.sonar.python.checks.tests.SkippedTestNoReasonCheck; +import org.sonar.python.checks.tests.SpecificExceptionAssertionCheck; +import org.sonar.python.checks.tests.SpecificWarningAssertionCheck; +import org.sonar.python.checks.tests.TestCasesShouldContainTestsCheck; import org.sonar.python.checks.tests.UnconditionalAssertionCheck; +import org.sonar.python.checks.tests.UseMonkeypatchFixtureCheck; +import org.sonar.python.checks.tests.UseTmpPathInsteadOfFactoryCheck; +import org.sonar.python.checks.tests.UselessPytestMarksCheck; +import org.sonar.python.checks.tests.XfailNoReasonCheck; public class OpenSourceCheckList { public static final String RESOURCE_FOLDER = "org/sonar/l10n/py/rules/python"; public static final String SONAR_WAY_PROFILE_LOCATION = RESOURCE_FOLDER + "/Sonar_way_profile.json"; + public static final String AI_QUALITY_PROFILE_LOCATION = RESOURCE_FOLDER + "/Sonar_agentic_AI_profile.json"; public Stream> getChecks() { return Stream.of( @@ -122,6 +149,8 @@ public Stream> getChecks() { AssertOnDissimilarTypesCheck.class, AssertAfterRaiseCheck.class, AssertOnTupleLiteralCheck.class, + AssertionArgumentOrderCheck.class, + AssertionInTryCheck.class, AsyncFunctionNotAsyncCheck.class, AsyncFunctionWithTimeoutCheck.class, AsyncioTaskNotStoredCheck.class, @@ -143,6 +172,11 @@ public Stream> getChecks() { BackslashInStringCheck.class, BackticksUsageCheck.class, BareRaiseInFinallyCheck.class, + BeautifulSoupClassListCheck.class, + BeautifulSoupDeprecatedNamesCheck.class, + BeautifulSoupParserCheck.class, + BeautifulSoupRawHtmlInsertionCheck.class, + BeautifulSoupNoneCheck.class, BindToAllNetworkInterfacesCheck.class, BooleanExpressionInExceptCheck.class, BooleanCheckNotInvertedCheck.class, @@ -158,6 +192,7 @@ public Stream> getChecks() { ChildRouterBeforeParentRegistrationCheck.class, CipherBlockChainingCheck.class, ClassComplexityCheck.class, + ClassFieldDefinedMultipleTimesCheck.class, ClassMethodFirstArgumentNameCheck.class, ClassNameCheck.class, ClearTextProtocolsCheck.class, @@ -165,10 +200,10 @@ public Stream> getChecks() { CollapsibleIfStatementsCheck.class, CollectionCreationWrappedInConstructorCheck.class, CollectionLengthComparisonCheck.class, - CommandLineArgsCheck.class, CommentedCodeCheck.class, CommentRegularExpressionCheck.class, ComparisonToNoneCheck.class, + CompositeAssertionCheck.class, CompressionModulesFromNamespaceCheck.class, ConfusingTypeCheckingCheck.class, ConfusingWalrusCheck.class, @@ -179,13 +214,20 @@ public Stream> getChecks() { CorsCheck.class, CorsMiddlewareOrderingCheck.class, CsrfDisabledCheck.class, - DataEncryptionCheck.class, + DataClassFunctionCallDefaultCheck.class, + DataClassOnEnumCheck.class, + DataclassFieldDefinitionCheck.class, DbNoPasswordCheck.class, DeadStoreCheck.class, DebugModeCheck.class, DedicatedAssertionCheck.class, + DedicatedExceptionAssertionCheck.class, + DuplicateParametrizeCasesCheck.class, + EmptyParametrizeValuesCheck.class, DefaultFactoryArgumentCheck.class, DeprecatedNumpyTypesCheck.class, + DeprecatedYieldFixtureCheck.class, + DictKeysMembershipTestCheck.class, DictionaryDuplicateKeyCheck.class, DictionaryStaticKeyCheck.class, DirectTypeComparisonCheck.class, @@ -199,19 +241,20 @@ public Stream> getChecks() { DjangoRenderContextCheck.class, DoublePrefixOperatorCheck.class, DuplicateArgumentCheck.class, + DuplicateBaseClassCheck.class, DuplicatedMethodFieldNamesCheck.class, DuplicatedMethodImplementationCheck.class, DuplicatesInCharacterClassCheck.class, - DynamicCodeExecutionCheck.class, EinopsSyntaxCheck.class, ElseAfterLoopsWithoutBreakCheck.class, - EmailSendingCheck.class, EmptyAlternativeCheck.class, EmptyCollectionConstructorCheck.class, + EmptyCollectionMembershipTestCheck.class, EmptyGroupCheck.class, EmptyFunctionCheck.class, EmptyNestedBlockCheck.class, EmptyStringRepetitionCheck.class, + EnumerateUnpackingCheck.class, ExceptionGroupCheck.class, ExceptionCauseTypeCheck.class, ExceptionNotThrownCheck.class, @@ -234,6 +277,7 @@ public Stream> getChecks() { FilePermissionsCheck.class, FileHeaderCopyrightCheck.class, FixmeCommentCheck.class, + FixtureParamDependenciesCheck.class, FlaskErrorHandlerStatusCheck.class, FlaskHardCodedJWTSecretKeyCheck.class, FlaskHardCodedSecretKeyCheck.class, @@ -257,6 +301,8 @@ public Stream> getChecks() { GraphemeClustersInClassesCheck.class, GraphQLDenialOfServiceCheck.class, GraphQLIntrospectionCheck.class, + GroupByIteratorReuseCheck.class, + GroupSimilarTestsParameterizedCheck.class, GroupReplacementCheck.class, HardCodedCredentialsCheck.class, HardCodedCredentialsEntropyCheck.class, @@ -270,6 +316,7 @@ public Stream> getChecks() { IgnoredParameterCheck.class, IgnoredSystemExitCheck.class, IdenticalExpressionOnBinaryOperatorCheck.class, + IdenticalAssertionArgumentsCheck.class, IdentityComparisonWithCachedTypesCheck.class, IdentityComparisonWithNewObjectCheck.class, IgnoredPureOperationsCheck.class, @@ -277,6 +324,8 @@ public Stream> getChecks() { ImpossibleBackReferenceCheck.class, ImpossibleBoundariesCheck.class, IncompatibleOperandsCheck.class, + InconsistentTupleReturnCheck.class, + IncompleteComparisonMethodsCheck.class, InconsistentTypeHintCheck.class, IncorrectExceptionTypeCheck.class, IncorrectParameterDatetimeConstructorsCheck.class, @@ -300,8 +349,10 @@ public Stream> getChecks() { LambdaAssignmentCheck.class, LdapAuthenticationCheck.class, LineLengthCheck.class, + ListIterableFirstElementCheck.class, LocalVariableAndParameterNameConventionCheck.class, - LoggersConfigurationCheck.class, + LoggingExceptionCheck.class, + LoggingBestPracticesCheck.class, LongIntegerWithLowercaseSuffixUsageCheck.class, LoopExecutingAtMostOnceCheck.class, LoopOverDictKeyValuesCheck.class, @@ -312,13 +363,19 @@ public Stream> getChecks() { MethodShouldBeStaticCheck.class, MissingDocstringCheck.class, MissingNewlineAtEndOfFileCheck.class, + MisspelledMockAssertionCheck.class, + MockPatchLambdaReturnValueCheck.class, + MocksShouldUseAutospecCheck.class, ModifiedParameterValueCheck.class, ModuleNameCheck.class, + MultipleInheritanceMROConflictCheck.class, MultipleWhitespaceCheck.class, + MutableDefaultValueCheck.class, NeedlessPassCheck.class, NestedCollectionsCreationCheck.class, NestedConditionalExpressionCheck.class, NestedControlFlowDepthCheck.class, + NestedLoopVariableReuseCheck.class, NewStyleClassCheck.class, NonCallableCalledCheck.class, NonStandardCryptographicAlgorithmCheck.class, @@ -341,7 +398,6 @@ public Stream> getChecks() { UnusedGroupNamesCheck.class, OctalEscapeCheck.class, OneStatementPerLineCheck.class, - OsExecCheck.class, OverwrittenCollectionEntryCheck.class, PandasAddMergeParametersCheck.class, PandasChainInstructionCheck.class, @@ -356,12 +412,32 @@ public Stream> getChecks() { PrivilegePolicyCheck.class, ProcessSignallingCheck.class, PropertyAccessorParameterCountCheck.class, + PropertyMethodWithoutReturnCheck.class, PytzUsageCheck.class, PseudoRandomCheck.class, PublicApiIsSecuritySensitiveCheck.class, PubliclyWritableDirectoriesCheck.class, PublicNetworkAccessToCloudResourcesCheck.class, + PydanticConfigDictValidationOptionsCheck.class, + PydanticCoreSerializationFallbackCheck.class, + PydanticDataclassRevalidationCheck.class, + PydanticDoubleUnderscorePrivateAttributeCheck.class, + PydanticFieldValidatorReturnCheck.class, + PydanticJsonSchemaInputTypeWithAfterModeCheck.class, PydanticOptionalFieldDefaultCheck.class, + PydanticMultipleInheritanceConfigCheck.class, + PydanticSkipValidationWithConstraintsCheck.class, + PytestAutouseParametrizedFixtureCheck.class, + PytestDecoratorParenthesesCheck.class, + PytestDefaultFixtureScopeCheck.class, + PytestFixtureMultipleYieldCheck.class, + PytestFixturePositionalArgsCheck.class, + PytestFixtureYieldTeardownCheck.class, + PytestModuleImportCheck.class, + PytestParameterDefaultValueCheck.class, + PytestPluginsConftestCheck.class, + PytestRaisesContextManagerCheck.class, + PytestUselessYieldFixtureCheck.class, PyTorchDataLoaderNumWorkersCheck.class, PytzTimeZoneInDatetimeConstructorCheck.class, RaiseOutsideExceptCheck.class, @@ -371,7 +447,6 @@ public Stream> getChecks() { PossessiveQuantifierContinuationCheck.class, RedundantRegexAlternativesCheck.class, ReluctantQuantifierCheck.class, - RegexCheck.class, ReluctantQuantifierWithEmptyContinuationCheck.class, ResourceAccessPolicyCheck.class, ReturnAndYieldInOneFunctionCheck.class, @@ -381,44 +456,57 @@ public Stream> getChecks() { S3BucketBlockPublicAccessCheck.class, S3BucketGrantedAccessCheck.class, S3BucketHTTPCommunicationCheck.class, - S3BucketServerEncryptionCheck.class, S3BucketVersioningCheck.class, SameBranchCheck.class, SameConditionCheck.class, SecureCookieCheck.class, SecureModeEncryptionAlgorithmsCheck.class, SelfAssignmentCheck.class, + SetDiscardOverRemoveCheck.class, SetDuplicateKeyCheck.class, + SetUpdateOverForLoopCheck.class, SideEffectInTfFunctionCheck.class, SillyEqualityCheck.class, SillyIdentityCheck.class, SingleCharacterAlternationCheck.class, SingleCharCharacterClassCheck.class, + SingleDispatchMixupCheck.class, + SingleInvocationRuntimeExceptionCheck.class, + SingleInvocationWarningCheck.class, SkippedTestNoReasonCheck.class, SkLearnEstimatorDontInitializeEstimatedValuesCheck.class, SleepZeroInAsyncCheck.class, + SortedMinMaxCheck.class, + SlotsAssignmentCheck.class, SpecialMethodParamListCheck.class, SpecialMethodReturnTypeCheck.class, + SpecificExceptionAssertionCheck.class, + SpecificWarningAssertionCheck.class, + TestCasesShouldContainTestsCheck.class, SQLQueriesCheck.class, - StandardInputCheck.class, + StartsWithEndsWithTupleCheck.class, + StopIterationInGeneratorCheck.class, StrftimeConfusingHourSystemCheck.class, StringFormatCorrectnessCheck.class, StringFormatMisuseCheck.class, StringLiteralDuplicationCheck.class, StringReplaceCheck.class, StrongCryptographicKeysCheck.class, + SumListConcatenationCheck.class, SklearnCachedPipelineDontAccessTransformersCheck.class, MissingHyperParameterCheck.class, NetworkCallsWithoutTimeoutsInLambdaCheck.class, SklearnPipelineSpecifyMemoryArgumentCheck.class, SklearnPipelineParameterAreCorrectCheck.class, SuperfluousCurlyBraceCheck.class, + SuperLinearRegexCheck.class, SynchronousFileOperationsInAsyncCheck.class, SynchronousHttpOperationsInAsyncCheck.class, SynchronousSubprocessOperationsInAsyncCheck.class, SynchronousOsCallsInAsyncCheck.class, TempFileCreationCheck.class, ImplicitlySkippedTestCheck.class, + IntentionalTestFailureMessageCheck.class, TaskGroupNurseryUsedOnlyOnceCheck.class, TemplateStringStructuralPatternMatchingCheck.class, TestClientContentParameterCheck.class, @@ -435,6 +523,8 @@ public Stream> getChecks() { TrailingCommentCheck.class, TrailingWhitespaceCheck.class, TypeAliasAnnotationCheck.class, + TypeVarCovariantAndContravariantCheck.class, + TypeVarNamingConventionCheck.class, TfFunctionDependOnOutsideVariableCheck.class, TfFunctionRecursivityCheck.class, TfInputShapeOnModelSubclassCheck.class, @@ -445,6 +535,9 @@ public Stream> getChecks() { RegexLookaheadCheck.class, RewriteCollectionConstructorAsComprehensionCheck.class, UnconditionalAssertionCheck.class, + UseMonkeypatchFixtureCheck.class, + UseTmpPathInsteadOfFactoryCheck.class, + UselessPytestMarksCheck.class, UndefinedNameAllPropertyCheck.class, UnencryptedSageMakerNotebookCheck.class, UnencryptedSqsQueueCheck.class, @@ -484,6 +577,7 @@ public Stream> getChecks() { WeakSSLProtocolCheck.class, WildcardImportCheck.class, WrongAssignmentOperatorCheck.class, + XfailNoReasonCheck.class, XMLParserXXEVulnerableCheck.class, XMLSignatureValidationCheck.class, DjangoModelFormFieldsCheck.class, diff --git a/python-checks/src/main/java/org/sonar/python/checks/OverwrittenCollectionEntryCheck.java b/python-checks/src/main/java/org/sonar/python/checks/OverwrittenCollectionEntryCheck.java index 36545a6463..f7def2b4a5 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/OverwrittenCollectionEntryCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/OverwrittenCollectionEntryCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/PandasAddMergeParametersCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PandasAddMergeParametersCheck.java index 1bc727dc76..79841be557 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PandasAddMergeParametersCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PandasAddMergeParametersCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/PandasChainInstructionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PandasChainInstructionCheck.java index 29e17913c3..c0ac31682a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PandasChainInstructionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PandasChainInstructionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -19,21 +19,19 @@ import java.util.ArrayList; import java.util.HashSet; import java.util.List; -import java.util.Objects; import java.util.Optional; import java.util.Set; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.AmbiguousSymbol; -import org.sonar.plugins.python.api.symbols.FunctionSymbol; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.QualifiedExpression; import org.sonar.plugins.python.api.tree.SubscriptionExpression; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.tree.TreeUtils; -import org.sonar.python.types.InferredTypes; +import org.sonar.python.types.v2.matchers.InternalTypeMatchers; @Rule(key = "S6742") public class PandasChainInstructionCheck extends PythonSubscriptionCheck { @@ -42,6 +40,10 @@ public class PandasChainInstructionCheck extends PythonSubscriptionCheck { private static final int MAX_CHAIN_LENGTH = 7; private static final String DATAFRAME_FQN = "pandas.core.frame.DataFrame"; + private static final TypeMatcher IS_DATAFRAME = TypeMatchers.isObjectOfType(DATAFRAME_FQN); + private static final TypeMatcher IS_OR_CONTAINS_DATAFRAME = TypeMatchers.any( + IS_DATAFRAME, + InternalTypeMatchers.isAnyTypeInUnionSatisfying(IS_DATAFRAME)); private final Set visited = new HashSet<>(); @@ -54,7 +56,7 @@ public void initialize(Context context) { private void checkChainedInstructions(SubscriptionContext ctx) { QualifiedExpression expr = (QualifiedExpression) ctx.syntaxNode(); List chain = visitQualifier(expr, new ArrayList<>()); - if (chain.size() >= MAX_CHAIN_LENGTH && isValidPandasCall(chain)) { + if (chain.size() >= MAX_CHAIN_LENGTH && isValidPandasCall(chain, ctx)) { ctx.addIssue(chain.iterator().next(), MESSAGE); } } @@ -94,44 +96,21 @@ private static Optional ignoreSubscriptionAndGetCallExpr(Subscri return Optional.empty(); } - private static boolean isValidPandasCall(List chain) { + private static boolean isValidPandasCall(List chain, SubscriptionContext ctx) { QualifiedExpression firstQualifiedExpression = chain.get(chain.size() - 1); - boolean isADataFrameMethodCall = Optional.ofNullable(firstQualifiedExpression.symbol()) - .map(Symbol::fullyQualifiedName) - .filter(fqn -> fqn.startsWith(DATAFRAME_FQN)) - .isPresent(); - - boolean isAFunctionReturningADataFrame = Optional.ofNullable(firstQualifiedExpression.symbol()) - .flatMap(PandasChainInstructionCheck::isReturnTypeADataFrame) - .orElse(false); + boolean isAFunctionReturningADataFrame = firstQualifiedExpression.parent() instanceof CallExpression callExpression + && callExpression.callee() == firstQualifiedExpression + && IS_OR_CONTAINS_DATAFRAME.isTrueFor(callExpression, ctx); + // We do not resolve "DataFrame.pipe" as pipe is a generic on NDFrame. + // As we get an unknown type on typeV2 we need to use the name instead boolean doesNotContainACallToPipe = chain.stream() - .map(QualifiedExpression::symbol) - .filter(Objects::nonNull) - .map(Symbol::fullyQualifiedName) - .filter(Objects::nonNull) - .noneMatch((DATAFRAME_FQN + ".pipe")::equals); - - boolean isADataFrame = DATAFRAME_FQN.equals(InferredTypes.fullyQualifiedTypeName(firstQualifiedExpression.qualifier().type())); + .noneMatch(qe -> "pipe".equals(qe.name().name())); - return (isADataFrameMethodCall || isAFunctionReturningADataFrame || isADataFrame) && doesNotContainACallToPipe; - } + boolean isADataFrame = IS_OR_CONTAINS_DATAFRAME.isTrueFor(firstQualifiedExpression.qualifier(), ctx); - private static Optional isReturnTypeADataFrame(Symbol symbol) { - return Optional.of(symbol) - .filter(s -> s.is(Symbol.Kind.AMBIGUOUS)) - .map(AmbiguousSymbol.class::cast) - .map(s -> s.alternatives().stream() - .filter(a -> a.is(Symbol.Kind.FUNCTION)) - .map(FunctionSymbol.class::cast) - .map(FunctionSymbol::annotatedReturnTypeName) - .anyMatch(DATAFRAME_FQN::equals)) - .or(() -> Optional.of(symbol) - .filter(s -> s.is(Symbol.Kind.FUNCTION)) - .map(FunctionSymbol.class::cast) - .map(FunctionSymbol::annotatedReturnTypeName) - .map(DATAFRAME_FQN::equals)); + return (isAFunctionReturningADataFrame || isADataFrame) && doesNotContainACallToPipe; } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/PandasDataFrameToNumpyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PandasDataFrameToNumpyCheck.java index 3392538c58..bc34bd05c6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PandasDataFrameToNumpyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PandasDataFrameToNumpyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/PandasModifyInPlaceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PandasModifyInPlaceCheck.java index 035c669705..a45b77502e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PandasModifyInPlaceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PandasModifyInPlaceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -21,26 +21,39 @@ import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.tree.TreeUtils; +import org.sonar.python.types.v2.matchers.InternalTypeMatchers; @Rule(key = "S6734") public class PandasModifyInPlaceCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Do not use \"inplace=True\" when modifying a dataframe."; - private static final Set FULLY_QUALIFIED_EXPRESSIONS = Set.of( - "pandas.core.frame.DataFrame.drop", - "pandas.core.frame.DataFrame.dropna", - "pandas.core.frame.DataFrame.drop_duplicates", - "pandas.core.frame.DataFrame.sort_values", - "pandas.core.frame.DataFrame.sort_index", - "pandas.core.frame.DataFrame.eval", - "pandas.core.frame.DataFrame.query"); + private static final Set METHOD_NAMES = Set.of( + "drop", + "dropna", + "drop_duplicates", + "sort_values", + "sort_index", + "eval", + "query"); + + private static final TypeMatcher IS_DATAFRAME = TypeMatchers.isObjectOfType("pandas.core.frame.DataFrame"); + private static final TypeMatcher IS_DATAFRAME_METHOD = TypeMatchers.isFunctionOwnerSatisfying( + TypeMatchers.isType("pandas.core.frame.DataFrame")); + private static final TypeMatcher IS_OR_CONTAINS_DATAFRAME = TypeMatchers.any( + IS_DATAFRAME, + InternalTypeMatchers.isAnyTypeInUnionSatisfying(IS_DATAFRAME)); + private static final TypeMatcher IS_OR_CONTAINS_DATAFRAME_METHOD = TypeMatchers.any( + IS_DATAFRAME_METHOD, + InternalTypeMatchers.isAnyTypeInUnionSatisfying(IS_DATAFRAME_METHOD)); @Override public void initialize(Context context) { @@ -49,15 +62,22 @@ public void initialize(Context context) { private static void checkInplaceParameter(SubscriptionContext ctx) { CallExpression callExpression = (CallExpression) ctx.syntaxNode(); - Optional.ofNullable(callExpression.calleeSymbol()) - .map(Symbol::fullyQualifiedName) - .filter(FULLY_QUALIFIED_EXPRESSIONS::contains) - .map(fqn -> TreeUtils.argumentByKeyword("inplace", callExpression.arguments())) + if (!(callExpression.callee() instanceof QualifiedExpression qualifiedExpression)) { + return; + } + if (!METHOD_NAMES.contains(qualifiedExpression.name().name())) { + return; + } + if (!IS_OR_CONTAINS_DATAFRAME_METHOD.isTrueFor(callExpression.callee(), ctx) + && !IS_OR_CONTAINS_DATAFRAME.isTrueFor(qualifiedExpression.qualifier(), ctx)) { + return; + } + RegularArgument inplaceArgument = TreeUtils.argumentByKeyword("inplace", callExpression.arguments()); + Optional.ofNullable(inplaceArgument) .map(RegularArgument::expression) .flatMap(TreeUtils.toOptionalInstanceOfMapper(Name.class)) .map(Name::name) .filter("True"::equals) - .flatMap(fqn -> Optional.ofNullable(TreeUtils.argumentByKeyword("inplace", callExpression.arguments()))) - .ifPresent(regularArgument -> ctx.addIssue(regularArgument, MESSAGE)); + .ifPresent(unused -> ctx.addIssue(inplaceArgument, MESSAGE)); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/PandasReadNoDataTypeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PandasReadNoDataTypeCheck.java index 358ecec7e5..be5752bad3 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PandasReadNoDataTypeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PandasReadNoDataTypeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/PandasToDatetimeFormatCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PandasToDatetimeFormatCheck.java index 5dca7b2a39..eee66cd9f3 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PandasToDatetimeFormatCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PandasToDatetimeFormatCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ParsingErrorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ParsingErrorCheck.java index b9c2d54b33..351b6d08dd 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ParsingErrorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ParsingErrorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/PreIncrementDecrementCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PreIncrementDecrementCheck.java index b68669aa7d..782b8cd37f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PreIncrementDecrementCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PreIncrementDecrementCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/PredictableSaltCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PredictableSaltCheck.java index df91ad2b88..777c864678 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PredictableSaltCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PredictableSaltCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -161,7 +161,7 @@ private static boolean hasRaisedOnSameSaltAndDerivedKeyMaterial(RegularArgument return false; } var issue = ctx.addIssue(argument, DIFFERENT_SALT_THAN_KEY_MATERIAL_MESSAGE); - usagesInDeriveCall.stream().forEach(arg -> issue.secondary(arg, SALT_IS_USED_HERE_MESSAGE)); + usagesInDeriveCall.forEach(arg -> issue.secondary(arg, SALT_IS_USED_HERE_MESSAGE)); return true; } diff --git a/python-checks/src/main/java/org/sonar/python/checks/PrintStatementUsageCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PrintStatementUsageCheck.java index 619900bb65..8f6db97e2a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PrintStatementUsageCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PrintStatementUsageCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/PropertyAccessorParameterCountCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PropertyAccessorParameterCountCheck.java index ca7ed6ed3f..7b19ab1b0c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PropertyAccessorParameterCountCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PropertyAccessorParameterCountCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/PropertyMethodWithoutReturnCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PropertyMethodWithoutReturnCheck.java new file mode 100644 index 0000000000..c7f73a79db --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/PropertyMethodWithoutReturnCheck.java @@ -0,0 +1,59 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.CheckUtils; + +@Rule(key = "S8504") +public class PropertyMethodWithoutReturnCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Add a return statement to this property method."; + private static final TypeMatcher PROPERTY_MATCHER = TypeMatchers.isType("property"); + private static final TypeMatcher ABSTRACT_METHOD_MATCHER = TypeMatchers.isType("abc.abstractmethod"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, ctx -> { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + + boolean isProperty = functionDef.decorators().stream() + .anyMatch(d -> PROPERTY_MATCHER.isTrueFor(d.expression(), ctx)); + boolean isAbstract = functionDef.decorators().stream() + .anyMatch(d -> ABSTRACT_METHOD_MATCHER.isTrueFor(d.expression(), ctx)); + + if (!isProperty || isAbstract) { + return; + } + + if (functionDef.body().statements().stream().allMatch(CheckUtils::isEmptyStatement)) { + return; + } + + var collector = ReturnCheckUtils.ReturnStmtCollector.collect(functionDef); + + if (collector.getReturnStmts().isEmpty() && !collector.containsYield() && !collector.raisesExceptions()) { + ctx.addIssue(functionDef.name(), MESSAGE); + } + }); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/PyTorchDataLoaderNumWorkersCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PyTorchDataLoaderNumWorkersCheck.java index 66104d4b3d..75bb26bdef 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PyTorchDataLoaderNumWorkersCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PyTorchDataLoaderNumWorkersCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/PydanticConfigDictValidationOptionsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PydanticConfigDictValidationOptionsCheck.java new file mode 100644 index 0000000000..9164baba26 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/PydanticConfigDictValidationOptionsCheck.java @@ -0,0 +1,65 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8953") +public class PydanticConfigDictValidationOptionsCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Enable at least one of \"validate_by_alias\" or \"validate_by_name\"."; + private static final String SECONDARY_MESSAGE = "Also set to \"False\" here."; + + private static final String VALIDATE_BY_ALIAS = "validate_by_alias"; + private static final String VALIDATE_BY_NAME = "validate_by_name"; + + private static final TypeMatcher IS_PYDANTIC_CONFIG_DICT = TypeMatchers.isType("pydantic.ConfigDict"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, PydanticConfigDictValidationOptionsCheck::checkCallExpression); + } + + private static void checkCallExpression(SubscriptionContext ctx) { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + + if (!IS_PYDANTIC_CONFIG_DICT.isTrueFor(callExpression.callee(), ctx)) { + return; + } + + RegularArgument validateByAliasArg = TreeUtils.argumentByKeyword(VALIDATE_BY_ALIAS, callExpression.arguments()); + RegularArgument validateByNameArg = TreeUtils.argumentByKeyword(VALIDATE_BY_NAME, callExpression.arguments()); + + if (validateByAliasArg == null || validateByNameArg == null) { + return; + } + + if (Expressions.isFalsy(validateByAliasArg.expression()) && Expressions.isFalsy(validateByNameArg.expression())) { + ctx.addIssue(validateByNameArg, MESSAGE).secondary(validateByAliasArg, SECONDARY_MESSAGE); + } + } + +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/PydanticCoreSerializationFallbackCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PydanticCoreSerializationFallbackCheck.java new file mode 100644 index 0000000000..785ea86f4b --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/PydanticCoreSerializationFallbackCheck.java @@ -0,0 +1,79 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8966") +public class PydanticCoreSerializationFallbackCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Add a \"fallback\" parameter to this pydantic-core serialization call."; + private static final String FALLBACK_KEYWORD = "fallback"; + + private static final TypeMatcher SERIALIZATION_CALL_MATCHER = TypeMatchers.any( + TypeMatchers.isType("pydantic_core.to_json"), + TypeMatchers.isType("pydantic_core.to_jsonable_python")); + + private static final TypeMatcher IS_PYDANTIC_BASE_MODEL_INSTANCE = TypeMatchers.isObjectInstanceOf("pydantic.BaseModel"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, PydanticCoreSerializationFallbackCheck::checkCall); + } + + private static void checkCall(SubscriptionContext ctx) { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + if (!SERIALIZATION_CALL_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return; + } + + var arguments = callExpression.arguments(); + if (arguments.isEmpty()) { + return; + } + + var firstArg = arguments.get(0); + if (!(firstArg instanceof RegularArgument regularArgument)) { + return; + } + + if (isFirstArgumentPydanticBaseModelInstance(regularArgument, ctx)) { + return; + } + + if (TreeUtils.argumentByKeyword(FALLBACK_KEYWORD, callExpression.arguments()) != null) { + return; + } + + ctx.addIssue(callExpression.callee(), MESSAGE); + } + + private static boolean isFirstArgumentPydanticBaseModelInstance(RegularArgument firstArg, SubscriptionContext ctx) { + if (firstArg.keywordArgument() == null) { + return !IS_PYDANTIC_BASE_MODEL_INSTANCE.evaluateFor(firstArg.expression(), ctx).isFalse(); + } + return false; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/PydanticDataclassRevalidationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PydanticDataclassRevalidationCheck.java new file mode 100644 index 0000000000..a23fcd61c3 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/PydanticDataclassRevalidationCheck.java @@ -0,0 +1,247 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.ArgList; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.BinaryExpression; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.DictionaryLiteral; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.KeyValuePair; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.SubscriptionExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.ClassType; +import org.sonar.plugins.python.api.types.v2.PythonType; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8978") +public class PydanticDataclassRevalidationCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Explicitly set 'revalidate_instances' in this Pydantic model's configuration."; + + private static final TypeMatcher IS_PYDANTIC_MODEL = TypeMatchers.isOrExtendsType("pydantic.BaseModel"); + + private static final TypeMatcher IS_CONFIG_DICT = TypeMatchers.isType("pydantic.ConfigDict"); + + private static final TypeMatcher IS_DATACLASS_DECORATOR = TypeMatchers.isType("dataclasses.dataclass"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, PydanticDataclassRevalidationCheck::checkClassDef); + } + + private static final String SECONDARY_MESSAGE = "The dataclass-typed field is defined here."; + + private static void checkClassDef(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + + if (!IS_PYDANTIC_MODEL.isTrueFor(classDef.name(), ctx)) { + return; + } + + if (hasExplicitRevalidateInstances(classDef, ctx) + || hasRevalidateInstancesKeywordArg(classDef) + || hasInheritedRevalidateInstances(classDef, ctx)) { + return; + } + + List dataclassFields = classDef.body().statements().stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(AnnotatedAssignment.class)) + .filter(aa -> isDataclassAnnotation(aa.annotation().expression(), ctx)) + .toList(); + + if (!dataclassFields.isEmpty()) { + var issue = ctx.addIssue(classDef.name(), MESSAGE); + dataclassFields.forEach(aa -> issue.secondary(aa.variable(), SECONDARY_MESSAGE)); + } + } + + /** + * Returns true if any ancestor of this class (per Python's MRO) explicitly sets + * {@code revalidate_instances} — either via {@code ConfigDict}/dict-literal assignment or as a + * class keyword argument. Uses {@link ClassType#mro()} for correct C3-linearized traversal, + * including diamond inheritance. Only ancestors whose {@code ClassDef} can be resolved in the + * same file are inspected; cross-file ancestors are conservatively ignored. + */ + private static boolean hasInheritedRevalidateInstances(ClassDef classDef, SubscriptionContext ctx) { + PythonType type = classDef.name().typeV2(); + if (!(type instanceof ClassType classType)) { + return false; + } + // Collect the full set of ancestor ClassTypes (skip self at index 0) + Set ancestors = new HashSet<>(classType.mro().orElse(List.of())); + ancestors.remove(classType); + if (ancestors.isEmpty()) { + return false; + } + // Walk base class Name expressions; for each one resolved to a same-file ClassDef, + // check whether it (or any of its same-file ancestors) sets revalidate_instances. + return collectSameFileClassDefs(classDef, ancestors).stream() + .anyMatch(ancestorDef -> hasExplicitRevalidateInstances(ancestorDef, ctx) + || hasRevalidateInstancesKeywordArg(ancestorDef)); + } + + /** + * Collects {@link ClassDef} AST nodes for all ancestors of {@code classDef} that appear in + * {@code ancestorTypes}, resolving transitively through same-file base classes. + */ + private static List collectSameFileClassDefs(ClassDef classDef, Set ancestorTypes) { + ArgList argList = classDef.args(); + if (argList == null) { + return List.of(); + } + List result = new ArrayList<>(); + for (Argument arg : argList.arguments()) { + if (!(arg instanceof RegularArgument regArg) || + regArg.keywordArgument() != null || + !(regArg.expression() instanceof Name name)) { + continue; + } + findClassDef(name.symbolV2()).ifPresent(baseClassDef -> { + if (ancestorTypes.contains(baseClassDef.name().typeV2())) { + result.add(baseClassDef); + result.addAll(collectSameFileClassDefs(baseClassDef, ancestorTypes)); + } + }); + } + return result; + } + + /** + * Returns true if the class body contains a {@code ConfigDict(revalidate_instances=...)} assignment + * with any value for {@code revalidate_instances}. + * The variable name on the left-hand side is not checked; instead the callee type is matched. + */ + private static boolean hasExplicitRevalidateInstances(ClassDef classDef, SubscriptionContext ctx) { + return classDef.body().statements().stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(AssignmentStatement.class)) + .anyMatch(stmt -> assignsConfigDictWithRevalidateInstances(stmt, ctx)); + } + + /** + * Returns true if the class declaration uses a keyword argument for {@code revalidate_instances}, + * e.g. {@code class Foo(BaseModel, revalidate_instances='always')}. + */ + private static boolean hasRevalidateInstancesKeywordArg(ClassDef classDef) { + ArgList argList = classDef.args(); + if (argList == null) { + return false; + } + return hasRevalidateInstancesKeyword(argList.arguments()); + } + + /** + * Returns true if the assignment's right-hand side explicitly sets {@code revalidate_instances}. + * Recognizes two forms: + *
    + *
  • {@code ConfigDict(revalidate_instances=...)} — call identified by callee type
    • + *
  • {@code {'revalidate_instances': ...}} — plain dict literal
    • + *
+ * If the RHS is a variable reference, it is resolved to its single assigned value first. + * This handles patterns like {@code COMMON_CONFIG = ConfigDict(revalidate_instances='always')} + * used as {@code model_config = COMMON_CONFIG} (possibly at module level or via chained aliases). + */ + private static boolean assignsConfigDictWithRevalidateInstances(AssignmentStatement stmt, SubscriptionContext ctx) { + Expression rhs = Expressions.ifNameGetSingleAssignedNonNameValue(stmt.assignedValue()).orElse(null); + if (rhs == null) { + return false; + } + if (rhs instanceof CallExpression callExpr && IS_CONFIG_DICT.isTrueFor(callExpr.callee(), ctx)) { + return hasRevalidateInstancesKeyword(callExpr.arguments()); + } + if (rhs instanceof DictionaryLiteral dict) { + return dict.elements().stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(KeyValuePair.class)) + .map(KeyValuePair::key) + .anyMatch(k -> k instanceof StringLiteral sl && "revalidate_instances".equals(sl.trimmedQuotesValue())); + } + return false; + } + + private static boolean hasRevalidateInstancesKeyword(List arguments) { + return arguments.stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(RegularArgument.class)) + .anyMatch(arg -> { + Name keyword = arg.keywordArgument(); + return keyword != null && "revalidate_instances".equals(keyword.name()); + }); + } + + /** + * Returns true if the given annotation expression refers to a class decorated with {@code @dataclass} + * that is defined in the same file. + * Handles bare names, generic wrappers ({@code Optional[X]}, {@code List[X]}, {@code Annotated[X, ...]}, etc.) + * and PEP-604 union syntax ({@code X | Y}). + */ + private static boolean isDataclassAnnotation(Expression annotationExpr, SubscriptionContext ctx) { + if (annotationExpr instanceof Name nameExpr) { + return findClassDef(nameExpr.symbolV2()) + .map(referencedClassDef -> isDecoratedWithDataclass(referencedClassDef, ctx)) + .orElse(false); + } + if (annotationExpr instanceof SubscriptionExpression subscriptionExpr) { + return subscriptionExpr.subscripts().expressions().stream() + .anyMatch(inner -> isDataclassAnnotation(inner, ctx)); + } + if (annotationExpr.is(Tree.Kind.BITWISE_OR)) { + BinaryExpression binExpr = (BinaryExpression) annotationExpr; + return isDataclassAnnotation(binExpr.leftOperand(), ctx) + || isDataclassAnnotation(binExpr.rightOperand(), ctx); + } + return false; + } + + private static Optional findClassDef(@Nullable SymbolV2 symbolV2) { + if (symbolV2 == null) { + return Optional.empty(); + } + return symbolV2.usages().stream() + .filter(usage -> usage.kind() == UsageV2.Kind.CLASS_DECLARATION) + .map(usage -> TreeUtils.firstAncestorOfKind(usage.tree(), Tree.Kind.CLASSDEF)) + .filter(Objects::nonNull) + .map(ClassDef.class::cast) + .findFirst(); + } + + private static boolean isDecoratedWithDataclass(ClassDef classDef, SubscriptionContext ctx) { + return classDef.decorators().stream() + .map(decorator -> decorator.expression() instanceof CallExpression callExpr ? callExpr.callee() : decorator.expression()) + .anyMatch(decoratorExpr -> IS_DATACLASS_DECORATOR.isTrueFor(decoratorExpr, ctx)); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/PydanticDoubleUnderscorePrivateAttributeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PydanticDoubleUnderscorePrivateAttributeCheck.java new file mode 100644 index 0000000000..b5578a2ac8 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/PydanticDoubleUnderscorePrivateAttributeCheck.java @@ -0,0 +1,91 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8973") +public class PydanticDoubleUnderscorePrivateAttributeCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Replace this double underscore prefix with a single underscore to avoid Python name mangling."; + + private static final TypeMatcher IS_PYDANTIC_MODEL = TypeMatchers.isOrExtendsType("pydantic.BaseModel"); + private static final TypeMatcher IS_PYDANTIC_PRIVATE_ATTR = TypeMatchers.isType("pydantic.PrivateAttr"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, PydanticDoubleUnderscorePrivateAttributeCheck::checkClassDef); + } + + private static void checkClassDef(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + + if (!IS_PYDANTIC_MODEL.isTrueFor(classDef.name(), ctx)) { + return; + } + + classDef.body().statements().stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(AnnotatedAssignment.class)) + .forEach(annotatedAssignment -> checkAttribute(ctx, annotatedAssignment.variable())); + + classDef.body().statements().stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(AssignmentStatement.class)) + .filter(stmt -> isPrivateAttrCall(ctx, stmt.assignedValue())) + .flatMap(stmt -> stmt.lhsExpressions().stream()) + .flatMap(exprList -> exprList.expressions().stream()) + .forEach(variable -> checkAttribute(ctx, variable)); + } + + private static boolean isPrivateAttrCall(SubscriptionContext ctx, Expression assignedValue) { + if (!(assignedValue instanceof CallExpression callExpression)) { + return false; + } + return IS_PYDANTIC_PRIVATE_ATTR.isTrueFor(callExpression.callee(), ctx); + } + + private static void checkAttribute(SubscriptionContext ctx, Expression variable) { + if (!(variable instanceof Name name)) { + return; + } + + String attributeName = name.name(); + if (hasDoubleUnderscorePrefix(attributeName)) { + ctx.addIssue(name, MESSAGE); + } + } + + /** + * Returns true if the name has a double leading underscore prefix but is NOT a dunder method/attribute + * (i.e., does not also end with double underscore like {@code __init__}). + */ + private static boolean hasDoubleUnderscorePrefix(String name) { + return name.startsWith("__") && !name.endsWith("__"); + } + +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/PydanticFieldValidatorReturnCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PydanticFieldValidatorReturnCheck.java new file mode 100644 index 0000000000..19f9773d3a --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/PydanticFieldValidatorReturnCheck.java @@ -0,0 +1,212 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.cfg.CfgBranchingBlock; +import org.sonar.plugins.python.api.cfg.ControlFlowGraph; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ForStatement; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.IfStatement; +import org.sonar.plugins.python.api.tree.ReturnStatement; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.StatementList; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.Tree.Kind; +import org.sonar.plugins.python.api.tree.WhileStatement; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.Expressions; + +/** + * Detects Pydantic {@code @field_validator} methods that have a code path without an explicit return value. + * When a field validator does not return a value, Pydantic silently stores {@code None} as the field value, + * violating the field's type contract without raising any error. + */ +@Rule(key = "S9134") +public class PydanticFieldValidatorReturnCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Add a return statement to this Pydantic field validator."; + + /** + * Matches {@code pydantic.functional_validators.field_validator} (direct submodule import): + * {@code from pydantic.functional_validators import field_validator} + * Matches {@code field_validator} re-exported through the {@code pydantic} package root: + * {@code from pydantic import field_validator} + * Uses FQN matching because the pydantic v1 stub does not declare this re-export, + * so the type resolves to {@code UnresolvedImportType[pydantic.field_validator]}. + */ + + private static final TypeMatcher FIELD_VALIDATOR_MATCHER = TypeMatchers.any(TypeMatchers.isType("pydantic.functional_validators.field_validator"), + TypeMatchers.withFQN("pydantic.field_validator")); + + private static final TypeMatcher IS_PYDANTIC_MODEL = TypeMatchers.isOrExtendsType("pydantic.BaseModel"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Kind.FUNCDEF, PydanticFieldValidatorReturnCheck::checkFunctionDef); + } + + private static void checkFunctionDef(SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + + if (!hasFieldValidatorDecorator(functionDef, ctx)) { + return; + } + + if (!isInsidePydanticModel(functionDef, ctx)) { + return; + } + + // Skip stub bodies: functions consisting solely of pass or ellipsis statements + if (functionDef.body().statements().stream().allMatch(CheckUtils::isEmptyStatement)) { + return; + } + + var collector = ReturnCheckUtils.ReturnStmtCollector.collect(functionDef); + + // Generators are not field validators in the conventional sense + if (collector.containsYield()) { + return; + } + + // Use the CFG to detect missing return values on any code path reaching the function exit. + ControlFlowGraph cfg = ctx.cfg(functionDef); + if (cfg == null || hasExceptOrFinally(cfg)) { + // CFG unavailable or contains try/except/finally: fall back to simple presence check. + // try/except/finally can produce end-predecessor blocks with empty elements() lists, + // making the CFG traversal unsafe. + if (collector.getReturnStmts().isEmpty() && !collector.raisesExceptions()) { + ctx.addIssue(functionDef.name(), MESSAGE); + } + return; + } + + List endStatements = cfg.end().predecessors().stream() + .map(block -> parentStatement(block.elements().get(block.elements().size() - 1))) + .filter(s -> !s.is(Kind.RAISE_STMT, Kind.ASSERT_STMT, Kind.WITH_STMT) && !isLoopWithReturn(s) && !isIfTruthy(s)) + .toList(); + + // If every path reaching the exit ends with a raise/assert, no issue needed. + if (endStatements.isEmpty()) { + return; + } + + // Check whether any path ends without an explicit return + boolean hasPathWithoutReturnValue = endStatements.stream() + .anyMatch(s -> !isReturnWithValue(s)); + + if (hasPathWithoutReturnValue) { + ctx.addIssue(functionDef.name(), MESSAGE); + } + } + + private static boolean hasFieldValidatorDecorator(FunctionDef functionDef, SubscriptionContext ctx) { + return functionDef.decorators().stream() + .anyMatch(d -> FIELD_VALIDATOR_MATCHER.isTrueFor(getDecoratorFunctionExpression(d), ctx)); + } + + private static Expression getDecoratorFunctionExpression(Decorator decorator) { + Expression expr = decorator.expression(); + if (expr instanceof CallExpression callExpr) { + return callExpr.callee(); + } + return expr; + } + + private static boolean isInsidePydanticModel(FunctionDef functionDef, SubscriptionContext ctx) { + Tree parent = functionDef.parent(); + if (parent != null) { + parent = parent.parent(); + } + if (!(parent instanceof ClassDef classDef)) { + return false; + } + return IS_PYDANTIC_MODEL.isTrueFor(classDef.name(), ctx); + } + + private static boolean isReturnWithValue(Statement statement) { + return statement.is(Kind.RETURN_STMT) && !((ReturnStatement) statement).expressions().isEmpty(); + } + + private static boolean hasExceptOrFinally(ControlFlowGraph cfg) { + return cfg.blocks().stream().anyMatch(block -> + block instanceof CfgBranchingBlock cfgBranchingBlock + && cfgBranchingBlock.branchingTree().is(Kind.EXCEPT_CLAUSE, Kind.FINALLY_CLAUSE)); + } + + /** + * Returns true if the statement is a {@code for} or {@code while} loop whose body contains at + * least one {@code return} statement (not in a nested function). Such loops cause the CFG to + * surface the loop statement itself as an implicit exit predecessor (the "loop exhausted" path), + * which is not a missing-return case when a return exists inside the loop body. + */ + private static boolean isLoopWithReturn(Statement statement) { + StatementList body = null; + if (statement.is(Kind.FOR_STMT)) { + body = ((ForStatement) statement).body(); + } else if (statement.is(Kind.WHILE_STMT)) { + body = ((WhileStatement) statement).body(); + } + if (body == null) { + return false; + } + return bodyContainsReturn(body); + } + + /** + * Returns true if the given tree contains a {@code return} statement that is not + * nested inside a nested function definition or lambda. + */ + private static boolean bodyContainsReturn(Tree tree) { + if (tree.is(Kind.RETURN_STMT)) { + return true; + } + if (tree.is(Kind.FUNCDEF, Kind.LAMBDA)) { + return false; + } + return tree.children().stream().anyMatch(PydanticFieldValidatorReturnCheck::bodyContainsReturn); + } + + /** + * Returns true if the statement is an {@code if True:} (or equivalent always-truthy condition) + * with no else branch. Such conditions cause the CFG to surface the {@code IF_STMT} itself as + * an implicit exit predecessor when the body always returns, which is not a missing-return case. + */ + private static boolean isIfTruthy(Statement statement) { + if (!statement.is(Kind.IF_STMT)) { + return false; + } + IfStatement ifStatement = (IfStatement) statement; + return ifStatement.elseBranch() == null && Expressions.isTruthy(ifStatement.condition()); + } + + private static Statement parentStatement(Tree tree) { + while (!(tree instanceof Statement)) { + tree = tree.parent(); + } + return (Statement) tree; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/PydanticJsonSchemaInputTypeWithAfterModeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PydanticJsonSchemaInputTypeWithAfterModeCheck.java new file mode 100644 index 0000000000..9fbdd646f7 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/PydanticJsonSchemaInputTypeWithAfterModeCheck.java @@ -0,0 +1,136 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import javax.annotation.CheckForNull; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonCheck; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.ArgList; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +/** + * Detects usage of {@code json_schema_input_type} with {@code mode='after'} (or no mode, which defaults to 'after') + * in Pydantic's {@code @field_validator} decorator. This combination always causes a {@code PydanticUserError} + * at class definition time. + */ +@Rule(key = "S8974") +public class PydanticJsonSchemaInputTypeWithAfterModeCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove \"json_schema_input_type\" or change the validator mode to \"before\", \"plain\", or \"wrap\"."; + private static final String SECONDARY_MESSAGE = "mode is set here."; + + private static final String MODE_ARGUMENT = "mode"; + private static final String JSON_SCHEMA_INPUT_TYPE_ARGUMENT = "json_schema_input_type"; + private static final String AFTER_MODE_VALUE = "after"; + + /** + * Matches {@code pydantic.functional_validators.field_validator} (direct import): + * {@code from pydantic.functional_validators import field_validator} + *

+ * Also covers aliased imports, e.g.: + * {@code from pydantic.functional_validators import field_validator as fv} + */ + private static final TypeMatcher FIELD_VALIDATOR_DIRECT_MATCHER = TypeMatchers.isType("pydantic.functional_validators.field_validator"); + + /** + * Matches {@code field_validator} re-exported through the {@code pydantic} package root: + * {@code from pydantic import field_validator} + *

+ * Uses FQN matching because the pydantic v1 stub does not declare this re-export, + * so the type resolves to {@code UnresolvedImportType[pydantic.field_validator]}. + * Also covers aliased imports, e.g.: + * {@code from pydantic import field_validator as fv} + */ + private static final TypeMatcher FIELD_VALIDATOR_REEXPORT_MATCHER = TypeMatchers.withFQN("pydantic.field_validator"); + + private static final TypeMatcher FIELD_VALIDATOR_MATCHER = TypeMatchers.any(FIELD_VALIDATOR_DIRECT_MATCHER, FIELD_VALIDATOR_REEXPORT_MATCHER); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.DECORATOR, PydanticJsonSchemaInputTypeWithAfterModeCheck::checkDecorator); + } + + private static void checkDecorator(SubscriptionContext ctx) { + Decorator decorator = (Decorator) ctx.syntaxNode(); + Expression decoratorFunctionExpr = getDecoratorFunctionExpression(decorator); + if (!FIELD_VALIDATOR_MATCHER.isTrueFor(decoratorFunctionExpr, ctx)) { + return; + } + ArgList argList = decorator.arguments(); + if (argList == null || argList.arguments().isEmpty()) { + return; + } + + RegularArgument jsonSchemaArg = TreeUtils.argumentByKeyword(JSON_SCHEMA_INPUT_TYPE_ARGUMENT, argList.arguments()); + if (jsonSchemaArg == null) { + return; + } + + var keywordArgument = jsonSchemaArg.keywordArgument(); + if (keywordArgument == null) { + return; + } + + RegularArgument modeArg = TreeUtils.argumentByKeyword(MODE_ARGUMENT, argList.arguments()); + if (!isAfterModeOrDefault(modeArg)) { + return; + } + + PythonCheck.PreciseIssue issue = ctx.addIssue(keywordArgument, MESSAGE); + if (modeArg != null) { + issue.secondary(modeArg.expression(), SECONDARY_MESSAGE); + } + } + + private static Expression getDecoratorFunctionExpression(Decorator decorator) { + Expression expr = decorator.expression(); + if (expr instanceof CallExpression callExpr) { + return callExpr.callee(); + } + return expr; + } + + /** + * Returns {@code true} if {@code mode} is absent (defaults to {@code 'after'}) or explicitly set to {@code 'after'}. + * Returns {@code false} for {@code 'before'}, {@code 'plain'}, {@code 'wrap'}, or any non-literal value. + */ + private static boolean isAfterModeOrDefault(@CheckForNull RegularArgument modeArg) { + if (modeArg == null) { + // No mode argument — defaults to 'after' + return true; + } + return isAfterLiteralValue(modeArg.expression()); + } + + private static boolean isAfterLiteralValue(Expression expression) { + // Only flag when mode is explicitly 'after'; unknown (non-literal) mode values → no issue + if (expression instanceof StringLiteral stringLiteral) { + return AFTER_MODE_VALUE.equals(stringLiteral.trimmedQuotesValue()); + } + return false; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/PydanticMultipleInheritanceConfigCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PydanticMultipleInheritanceConfigCheck.java new file mode 100644 index 0000000000..25deb2dc33 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/PydanticMultipleInheritanceConfigCheck.java @@ -0,0 +1,143 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.ArgList; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.ClassType; +import org.sonar.plugins.python.api.types.v2.Member; +import org.sonar.plugins.python.api.types.v2.PythonType; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S8963") +public class PydanticMultipleInheritanceConfigCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Refactor this Pydantic model to avoid multiple inheritance with conflicting configurations."; + + private static final TypeMatcher IS_PYDANTIC_MODEL = TypeMatchers.isOrExtendsType("pydantic.BaseModel"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, PydanticMultipleInheritanceConfigCheck::checkClassDef); + } + + private static void checkClassDef(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + + if (!IS_PYDANTIC_MODEL.isTrueFor(classDef.name(), ctx)) { + return; + } + + ArgList argList = classDef.args(); + if (argList == null) { + return; + } + + List superClasses = collectSuperClasses(argList); + if (superClasses.size() < 2) { + return; + } + + // Exception: the model class itself explicitly defines model_config, making the + // configuration explicit and predictable (as stated in the rule's Exceptions section). + if (classDefinesModelConfigLocally(classDef)) { + return; + } + + Set visitedClassesDefiningModelConfig = new HashSet<>(); + List superClassesWithNewModelConfig = new ArrayList<>(); + + for (Expression superClass : superClasses) { + Set classesDefiningModelConfig = findModelConfigDefiners(superClass); + boolean introducesNewModelConfigClass = false; + for (ClassType classDefiningModelConfig : classesDefiningModelConfig) { + if (visitedClassesDefiningModelConfig.add(classDefiningModelConfig)) { + introducesNewModelConfigClass = true; + } + } + if (introducesNewModelConfigClass) { + superClassesWithNewModelConfig.add(superClass); + } + } + + reportIfConflictingConfigs(ctx, classDef, superClassesWithNewModelConfig); + } + + private static boolean classDefinesModelConfigLocally(ClassDef classDef) { + PythonType type = classDef.name().typeV2(); + if (type instanceof ClassType classType) { + return definesModelConfigLocally(classType); + } + return false; + } + + private static List collectSuperClasses(ArgList argList) { + List superClasses = new ArrayList<>(); + for (Argument argument : argList.arguments()) { + if (argument instanceof RegularArgument regularArgument && regularArgument.keywordArgument() == null) { + superClasses.add(regularArgument.expression()); + } + } + return superClasses; + } + + private static void reportIfConflictingConfigs( + SubscriptionContext ctx, + ClassDef classDef, + List superClassesWithNewModelConfig) { + if (superClassesWithNewModelConfig.size() >= 2) { + PreciseIssue issue = ctx.addIssue(classDef.name(), MESSAGE); + for (Expression superClass : superClassesWithNewModelConfig) { + issue.secondary(superClass, "This base class defines \"model_config\"."); + } + } + } + + /** + * Returns the set of ClassType objects in the MRO of {@code superClass} that locally define + * {@code model_config}. + */ + private static Set findModelConfigDefiners(Expression superClass) { + PythonType type = superClass.typeV2(); + if (!(type instanceof ClassType classType)) { + return Set.of(); + } + Set classesDefiningModelConfig = new HashSet<>(); + for (ClassType ancestor : classType.mro().orElse(List.of())) { + if (definesModelConfigLocally(ancestor)) { + classesDefiningModelConfig.add(ancestor); + } + } + return classesDefiningModelConfig; + } + + private static boolean definesModelConfigLocally(ClassType classType) { + return classType.members().stream().map(Member::name).anyMatch("model_config"::equals); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/PydanticOptionalFieldDefaultCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PydanticOptionalFieldDefaultCheck.java index 72da396e64..d6db594f64 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PydanticOptionalFieldDefaultCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PydanticOptionalFieldDefaultCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -22,7 +22,6 @@ import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.tree.AnnotatedAssignment; import org.sonar.plugins.python.api.tree.Argument; -import org.sonar.plugins.python.api.tree.BinaryExpression; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.ClassDef; import org.sonar.plugins.python.api.tree.Expression; @@ -43,8 +42,6 @@ public class PydanticOptionalFieldDefaultCheck extends PythonSubscriptionCheck { private static final TypeMatcher IS_PYDANTIC_FIELD = TypeMatchers.isType("pydantic.Field"); private static final TypeMatcher IS_TYPING_OPTIONAL = TypeMatchers.isType("typing.Optional"); - private static final TypeMatcher IS_TYPING_UNION = TypeMatchers.isType("typing.Union"); - private static final TypeMatcher IS_NONE_TYPE = TypeMatchers.isObjectOfType("NoneType"); @Override public void initialize(Context context) { @@ -67,65 +64,23 @@ private static void checkField(SubscriptionContext ctx, AnnotatedAssignment anno TypeAnnotation annotation = annotatedAssignment.annotation(); Expression annotationExpr = annotation.expression(); - if (!isOptionalType(annotationExpr, ctx)) { + if (!isTypingOptional(annotationExpr, ctx)) { return; } Expression assignedValue = annotatedAssignment.assignedValue(); - - boolean hasNoDefault = assignedValue == null; - boolean hasFieldWithEllipsis = assignedValue != null && isFieldCallWithEllipsis(ctx, assignedValue); - - if (hasNoDefault || hasFieldWithEllipsis) { + if (assignedValue == null || isFieldCallWithEllipsis(ctx, assignedValue)) { ctx.addIssue(annotationExpr, MESSAGE); } } - private static boolean isOptionalType(Expression annotationExpr, SubscriptionContext ctx) { - // Case 1: T | None (BinaryExpression with BITWISE_OR) - if (annotationExpr.is(Tree.Kind.BITWISE_OR)) { - BinaryExpression binaryExpr = (BinaryExpression) annotationExpr; - return containsNone(binaryExpr, ctx); - } - - // Case 2: Optional[T] or Union[T, None] (SubscriptionExpression) + private static boolean isTypingOptional(Expression annotationExpr, SubscriptionContext ctx) { if (annotationExpr instanceof SubscriptionExpression subscriptionExpr) { - return isOptionalOrUnionWithNone(subscriptionExpr, ctx); + return IS_TYPING_OPTIONAL.isTrueFor(subscriptionExpr.object(), ctx); } - return false; } - private static boolean containsNone(BinaryExpression binaryExpr, SubscriptionContext ctx) { - return isNoneExpression(binaryExpr.leftOperand(), ctx) || - isNoneExpression(binaryExpr.rightOperand(), ctx) || - (binaryExpr.leftOperand().is(Tree.Kind.BITWISE_OR) && containsNone((BinaryExpression) binaryExpr.leftOperand(), ctx)) || - (binaryExpr.rightOperand().is(Tree.Kind.BITWISE_OR) && containsNone((BinaryExpression) binaryExpr.rightOperand(), ctx)); - } - - private static boolean isNoneExpression(Expression expr, SubscriptionContext ctx) { - return IS_NONE_TYPE.isTrueFor(expr, ctx); - } - - private static boolean isOptionalOrUnionWithNone(SubscriptionExpression subscriptionExpr, SubscriptionContext ctx) { - Expression subscriptedObj = subscriptionExpr.object(); - - if (IS_TYPING_OPTIONAL.isTrueFor(subscriptedObj, ctx)) { - return true; - } - - if (IS_TYPING_UNION.isTrueFor(subscriptedObj, ctx)) { - return subscriptsContainNone(subscriptionExpr, ctx); - } - - return false; - } - - private static boolean subscriptsContainNone(SubscriptionExpression subscriptionExpr, SubscriptionContext ctx) { - return subscriptionExpr.subscripts().expressions().stream() - .anyMatch(expr -> isNoneExpression(expr, ctx)); - } - private static boolean isFieldCallWithEllipsis(SubscriptionContext ctx, Expression assignedValue) { if (!(assignedValue instanceof CallExpression callExpr)) { return false; diff --git a/python-checks/src/main/java/org/sonar/python/checks/PydanticSkipValidationWithConstraintsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PydanticSkipValidationWithConstraintsCheck.java new file mode 100644 index 0000000000..034aa64871 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/PydanticSkipValidationWithConstraintsCheck.java @@ -0,0 +1,230 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.SubscriptionExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.TypeAnnotation; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8971") +public class PydanticSkipValidationWithConstraintsCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove either \"SkipValidation\" or the validation constraints from this annotation."; + + private static final TypeMatcher IS_PYDANTIC_MODEL = TypeMatchers.isOrExtendsType("pydantic.BaseModel"); + + private static final TypeMatcher IS_TYPING_ANNOTATED = TypeMatchers.any( + TypeMatchers.isType("typing.Annotated"), + TypeMatchers.isType("typing_extensions.Annotated")); + + private static final TypeMatcher IS_SKIP_VALIDATION = TypeMatchers.any( + TypeMatchers.withFQN("pydantic.SkipValidation"), + TypeMatchers.withFQN("pydantic.functional_validators.SkipValidation")); + + private static final TypeMatcher IS_PYDANTIC_FIELD = TypeMatchers.isType("pydantic.fields.Field"); + + /** + * Keyword arguments of pydantic.Field() that impose actual value constraints on field inputs. + * Only pure value-bound constraints are included: numeric bounds, length limits, and pattern. + * Arguments such as default, alias, description, title, etc. are metadata-only. + * Behavioral flags are intentionally excluded: + * - strict, allow_inf_nan, coerce_numbers_to_str, fail_fast: control how validation runs, + * but with SkipValidation no validation runs at all, so these have no effect. + * - discriminator: structural union routing metadata, not a value constraint. + */ + private static final Set FIELD_VALIDATION_CONSTRAINT_ARGS = Set.of( + "gt", "ge", "lt", "le", + "multiple_of", + "min_length", "max_length", + "pattern", + "max_digits", "decimal_places"); + + private static final TypeMatcher IS_VALIDATION_CONSTRAINT = TypeMatchers.any( + TypeMatchers.withFQN("pydantic.StringConstraints"), + TypeMatchers.withFQN("pydantic.types.StringConstraints"), + TypeMatchers.withFQN("pydantic.AfterValidator"), + TypeMatchers.withFQN("pydantic.functional_validators.AfterValidator"), + TypeMatchers.withFQN("pydantic.BeforeValidator"), + TypeMatchers.withFQN("pydantic.functional_validators.BeforeValidator"), + TypeMatchers.withFQN("pydantic.PlainValidator"), + TypeMatchers.withFQN("pydantic.functional_validators.PlainValidator"), + TypeMatchers.withFQN("pydantic.WrapValidator"), + TypeMatchers.withFQN("pydantic.functional_validators.WrapValidator"), + TypeMatchers.withFQN("pydantic.WrapSerializer"), + TypeMatchers.withFQN("pydantic.functional_serializers.WrapSerializer"), + TypeMatchers.withFQN("pydantic.PlainSerializer"), + TypeMatchers.withFQN("pydantic.functional_serializers.PlainSerializer")); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, PydanticSkipValidationWithConstraintsCheck::checkClassDef); + } + + private static void checkClassDef(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + + if (!IS_PYDANTIC_MODEL.isTrueFor(classDef.name(), ctx)) { + return; + } + + classDef.body().statements().stream() + .flatMap(TreeUtils.toStreamInstanceOfMapper(AnnotatedAssignment.class)) + .forEach(annotatedAssignment -> checkFieldAnnotation(ctx, annotatedAssignment)); + } + + private static void checkFieldAnnotation(SubscriptionContext ctx, AnnotatedAssignment annotatedAssignment) { + TypeAnnotation annotation = annotatedAssignment.annotation(); + Expression annotationExpr = annotation.expression(); + + if (!(annotationExpr instanceof SubscriptionExpression subscriptionExpr) || + !IS_TYPING_ANNOTATED.isTrueFor(subscriptionExpr.object(), ctx)) { + return; + } + + // Collect all subscript elements from this Annotated and any nested Annotated + List allElements = collectAnnotatedElements(subscriptionExpr, ctx); + + Expression skipValidationExpr = allElements.stream() + .filter(expr -> isSkipValidation(expr, ctx)) + .findFirst() + .orElse(null); + + if (skipValidationExpr == null) { + return; + } + + List constraintSecondaryExprs = allElements.stream() + .map(expr -> resolveConstraintSecondary(expr, ctx)) + .filter(Optional::isPresent) + .map(Optional::get) + .toList(); + + if (!constraintSecondaryExprs.isEmpty()) { + var issue = ctx.addIssue(skipValidationExpr, MESSAGE); + constraintSecondaryExprs.forEach(expr -> issue.secondary(expr, "Validation constraint is set here.")); + } + } + + /** + * Recursively collects all non-type elements from Annotated[...] subscripts. + * The first element in Annotated is the actual type (skipped). All subsequent + * elements are metadata/constraints. Nested Annotated[...] are unwrapped. + */ + private static List collectAnnotatedElements(SubscriptionExpression annotatedExpr, SubscriptionContext ctx) { + List elements = new ArrayList<>(); + List subscriptExprs = annotatedExpr.subscripts().expressions(); + + // subscriptExprs[0] is the annotated type, subscriptExprs[1..] are metadata + for (int i = 1; i < subscriptExprs.size(); i++) { + Expression element = subscriptExprs.get(i); + // If this element is itself an Annotated[...], flatten it recursively + if (element instanceof SubscriptionExpression nestedSubscription + && IS_TYPING_ANNOTATED.isTrueFor(nestedSubscription.object(), ctx)) { + elements.addAll(collectAnnotatedElements(nestedSubscription, ctx)); + } else { + elements.add(element); + } + } + + // Also recurse into the type argument if it is a nested Annotated + if (!subscriptExprs.isEmpty()) { + Expression typeArg = subscriptExprs.get(0); + if (typeArg instanceof SubscriptionExpression nestedAnnotated + && IS_TYPING_ANNOTATED.isTrueFor(nestedAnnotated.object(), ctx)) { + elements.addAll(collectAnnotatedElements(nestedAnnotated, ctx)); + } + } + + return elements; + } + + private static boolean isSkipValidation(Expression expr, SubscriptionContext ctx) { + // SkipValidation can appear as a bare name or as SkipValidation[T] subscription + if (expr instanceof SubscriptionExpression subscriptionExpr) { + return IS_SKIP_VALIDATION.isTrueFor(subscriptionExpr.object(), ctx); + } + return IS_SKIP_VALIDATION.isTrueFor(expr, ctx); + } + + /** + * Returns the expression to use as the secondary location if the given expression is a validation + * constraint (or a name that resolves to one), or empty otherwise. + * + *

For direct constraint expressions (e.g. {@code Field(gt=0)}, {@code AfterValidator(...)}), + * the expression itself is returned. For bare name references (e.g. {@code constraint} where + * {@code constraint = Field(gt=0)} is assigned in the class body), the single assigned value is + * returned so the secondary location points at the constraint definition, not the reference.

+ */ + private static Optional resolveConstraintSecondary(Expression expr, SubscriptionContext ctx) { + if (isDirectConstraint(expr, ctx)) { + return Optional.of(expr); + } + // If expr is a bare name, check whether it was assigned a single constraint value. + if (expr instanceof Name name) { + Expression assigned = Expressions.singleAssignedValue(name); + if (assigned != null && isDirectConstraint(assigned, ctx)) { + return Optional.of(assigned); + } + } + return Optional.empty(); + } + + private static boolean isDirectConstraint(Expression expr, SubscriptionContext ctx) { + // Constraints typically appear as CallExpression: Field(gt=0), StringConstraints(...) + if (expr instanceof CallExpression callExpr) { + // Non-Field constraints (validators, serializers, StringConstraints): always count + if (IS_VALIDATION_CONSTRAINT.isTrueFor(callExpr.callee(), ctx)) { + return true; + } + // Field(): only count as a constraint when at least one validation-specific kwarg is present. + // Calls like Field(default=0), Field(alias="x"), Field(description="...") are metadata-only + // and should not be flagged when combined with SkipValidation. + if (IS_PYDANTIC_FIELD.isTrueFor(callExpr.callee(), ctx)) { + return hasFieldValidationConstraintArg(callExpr); + } + } + // Some validators can be used as bare references too + return IS_VALIDATION_CONSTRAINT.isTrueFor(expr, ctx); + } + + private static boolean hasFieldValidationConstraintArg(CallExpression callExpr) { + return callExpr.arguments().stream() + .filter(RegularArgument.class::isInstance) + .map(arg -> ((RegularArgument) arg).keywordArgument()) + .filter(Objects::nonNull) + .map(Name::name) + .anyMatch(FIELD_VALIDATION_CONSTRAINT_ARGS::contains); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/PytzTimeZoneInDatetimeConstructorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PytzTimeZoneInDatetimeConstructorCheck.java index af95e147f2..d66cea20bd 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PytzTimeZoneInDatetimeConstructorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PytzTimeZoneInDatetimeConstructorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -18,38 +18,34 @@ import java.util.Comparator; import java.util.List; -import java.util.Optional; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.cfg.fixpoint.ReachingDefinitionsAnalysis; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.tree.TreeUtils; @Rule(key = "S6887") public class PytzTimeZoneInDatetimeConstructorCheck extends PythonSubscriptionCheck { - private ReachingDefinitionsAnalysis reachingDefinitionsAnalysis; private static final String MESSAGE = "Don't pass a \"pytz.timezone\" to the \"datetime.datetime\" constructor."; private static final String SECONDARY_MESSAGE = "The pytz.timezone is created here."; + private static final TypeMatcher DATETIME_DATETIME = TypeMatchers.isType("datetime.datetime"); + private static final TypeMatcher PYTZ_TIMEZONE = TypeMatchers.isType("pytz.timezone"); @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, - ctx -> reachingDefinitionsAnalysis = new ReachingDefinitionsAnalysis(ctx.pythonFile())); - - context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, this::checkCallExpression); + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, PytzTimeZoneInDatetimeConstructorCheck::checkCallExpression); } - private void checkCallExpression(SubscriptionContext context) { + private static void checkCallExpression(SubscriptionContext context) { CallExpression callExpression = (CallExpression) context.syntaxNode(); - Symbol calleeSymbol = callExpression.calleeSymbol(); - if (calleeSymbol != null && "datetime.datetime".equals(calleeSymbol.fullyQualifiedName())) { + if (DATETIME_DATETIME.isTrueFor(callExpression.callee(), context)) { RegularArgument argument = TreeUtils.nthArgumentOrKeyword(7, "tzinfo", callExpression.arguments()); if (argument == null) { return; @@ -58,19 +54,18 @@ private void checkCallExpression(SubscriptionContext context) { } } - private void checkArgument(RegularArgument argument, SubscriptionContext context) { + private static void checkArgument(RegularArgument argument, SubscriptionContext context) { if (argument.expression().is(Tree.Kind.CALL_EXPR)) { CallExpression callExpression = (CallExpression) argument.expression(); - Symbol calleeSymbol = callExpression.calleeSymbol(); - if (!(calleeSymbol != null && "pytz.timezone".equals(calleeSymbol.fullyQualifiedName()))) { + if (!PYTZ_TIMEZONE.isTrueFor(callExpression.callee(), context)) { return; } context.addIssue(argument, MESSAGE); } else if (argument.expression().is(Tree.Kind.NAME)) { - List allSecondaryLocations = reachingDefinitionsAnalysis.valuesAtLocation((Name) argument.expression()).stream() + List allSecondaryLocations = context.valuesAtLocation((Name) argument.expression()).stream() .filter(expression -> expression.is(Tree.Kind.CALL_EXPR)) .map(CallExpression.class::cast) - .filter(call -> Optional.ofNullable(call.calleeSymbol()).map(symbol ->"pytz.timezone".equals(symbol.fullyQualifiedName())).orElse(false)) + .filter(call -> PYTZ_TIMEZONE.isTrueFor(call.callee(), context)) .sorted(Comparator.comparingInt(call -> call.firstToken().line())) .toList(); diff --git a/python-checks/src/main/java/org/sonar/python/checks/PytzUsageCheck.java b/python-checks/src/main/java/org/sonar/python/checks/PytzUsageCheck.java index dda8b19f6e..0205ce07e9 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/PytzUsageCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/PytzUsageCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/RaiseOutsideExceptCheck.java b/python-checks/src/main/java/org/sonar/python/checks/RaiseOutsideExceptCheck.java index 6db2e6fd72..821d6be892 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/RaiseOutsideExceptCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/RaiseOutsideExceptCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/RandomSeedCheck.java b/python-checks/src/main/java/org/sonar/python/checks/RandomSeedCheck.java index 80065986b1..1a86686264 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/RandomSeedCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/RandomSeedCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -32,7 +32,6 @@ import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.cfg.fixpoint.ReachingDefinitionsAnalysis; import org.sonar.python.checks.cdk.CdkPredicate; import org.sonar.python.semantic.ClassSymbolImpl; import org.sonar.python.semantic.SymbolUtils; @@ -63,8 +62,6 @@ public class RandomSeedCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Provide a seed for this random generator."; private static final String SKLEARN_MESSAGE = "Provide a seed for the random_state parameter."; - private ReachingDefinitionsAnalysis reachingDefinitionsAnalysis; - private static Predicate keywordAbsentOrNotIn(String keyword, String... restrictedValues) { Set restrictedValueSet = Set.of(restrictedValues); return call -> { @@ -99,7 +96,6 @@ private static Predicate probabilityArgAbsent() { public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> { - this.reachingDefinitionsAnalysis = new ReachingDefinitionsAnalysis(ctx.pythonFile()); this.typeCheckMap = new TypeCheckMap<>(); SKLEARN_EXCEPTIONS.forEach((fqn, predicate) -> this.typeCheckMap.put(ctx.typeChecker().typeCheckBuilder().isTypeWithFqn(fqn), predicate)); }); @@ -114,12 +110,12 @@ private void checkEmptySeedCall(SubscriptionContext ctx) { maybeCalleeSymbol .map(Symbol::fullyQualifiedName) .map(SEED_METHODS_TO_CHECK::get) - .filter(argName -> isArgumentAbsentOrNone(TreeUtils.nthArgumentOrKeyword(0, argName, call.arguments()))) + .filter(argName -> isArgumentAbsentOrNone(TreeUtils.nthArgumentOrKeyword(0, argName, call.arguments()), ctx)) .map(arg -> MESSAGE) .or(() -> maybeCalleeSymbol .filter(symbol -> symbol.fullyQualifiedName() != null && symbol.fullyQualifiedName().startsWith(SKLEARN_FQN)) .filter(RandomSeedCheck::hasRandomStateParameter) - .filter(symbol -> isArgumentAbsentOrNone(TreeUtils.argumentByKeyword(SKLEARN_ARG_NAME, call.arguments()))) + .filter(symbol -> isArgumentAbsentOrNone(TreeUtils.argumentByKeyword(SKLEARN_ARG_NAME, call.arguments()), ctx)) .filter(symbol -> !isSKLearnException(call)) .map(symbol -> SKLEARN_MESSAGE)) .ifPresent(message -> ctx.addIssue(call.callee(), message)); @@ -156,14 +152,14 @@ private static Optional isFunctionWithRandomStateParameter(Symbol calle .anyMatch(SKLEARN_ARG_NAME::equals)); } - private boolean isArgumentAbsentOrNone(@Nullable RegularArgument arg) { - return arg == null || arg.expression().is(Tree.Kind.NONE) || isAssignedNone(arg.expression()); + private static boolean isArgumentAbsentOrNone(@Nullable RegularArgument arg, SubscriptionContext ctx) { + return arg == null || arg.expression().is(Tree.Kind.NONE) || isAssignedNone(arg.expression(), ctx); } - private boolean isAssignedNone(Expression exp) { + private static boolean isAssignedNone(Expression exp, SubscriptionContext ctx) { return Optional.of(exp) .flatMap(TreeUtils.toOptionalInstanceOfMapper(Name.class)) - .map(reachingDefinitionsAnalysis::valuesAtLocation) + .map(ctx::valuesAtLocation) .filter(Predicate.not(Set::isEmpty)) .filter(values -> values.stream().allMatch(value -> value.is(Tree.Kind.NONE))).isPresent(); } diff --git a/python-checks/src/main/java/org/sonar/python/checks/RedundantJumpCheck.java b/python-checks/src/main/java/org/sonar/python/checks/RedundantJumpCheck.java index b9abd605da..a25322bae3 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/RedundantJumpCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/RedundantJumpCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -24,8 +24,6 @@ import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.cfg.ControlFlowGraph; -import org.sonar.plugins.python.api.tree.FileInput; -import org.sonar.plugins.python.api.tree.FunctionDef; import org.sonar.plugins.python.api.tree.ReturnStatement; import org.sonar.plugins.python.api.tree.Statement; import org.sonar.plugins.python.api.tree.StatementList; @@ -33,6 +31,7 @@ import org.sonar.plugins.python.api.tree.Tree.Kind; import org.sonar.python.cfg.PythonCfgBranchingBlock; import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.python.checks.utils.MarimoUtils; import org.sonar.python.quickfix.TextEditUtils; import org.sonar.python.tree.TreeUtils; @@ -43,8 +42,8 @@ public class RedundantJumpCheck extends PythonSubscriptionCheck { @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Kind.FILE_INPUT, ctx -> checkCfg(ControlFlowGraph.build((FileInput) ctx.syntaxNode(), ctx.pythonFile()), ctx)); - context.registerSyntaxNodeConsumer(Kind.FUNCDEF, ctx -> checkCfg(ControlFlowGraph.build((FunctionDef) ctx.syntaxNode(), ctx.pythonFile()), ctx)); + context.registerSyntaxNodeConsumer(Kind.FILE_INPUT, ctx -> checkCfg(ctx.cfg(ctx.syntaxNode()), ctx)); + context.registerSyntaxNodeConsumer(Kind.FUNCDEF, ctx -> checkCfg(ctx.cfg(ctx.syntaxNode()), ctx)); } private static void checkCfg(@Nullable ControlFlowGraph cfg, SubscriptionContext ctx) { @@ -56,7 +55,7 @@ private static void checkCfg(@Nullable ControlFlowGraph cfg, SubscriptionContext .forEach(cfgBlock -> { List elements = cfgBlock.elements(); Tree lastElement = elements.get(elements.size() - 1); - if (!isException(lastElement)) { + if (!isException(lastElement, ctx)) { var issue = ctx.addIssue(lastElement, message(lastElement)); addQuickFix(lastElement, issue); @@ -94,11 +93,12 @@ private static boolean isReturnWithExpression(Tree lastElement) { return lastElement.is(Kind.RETURN_STMT) && !((ReturnStatement) lastElement).expressions().isEmpty(); } - private static boolean isException(Tree lastElement) { + private static boolean isException(Tree lastElement, SubscriptionContext ctx) { return lastElement.is(Kind.RAISE_STMT) || isReturnWithExpression(lastElement) || isInsideSingleStatementBlock(lastElement) - || hasTryAncestor(lastElement); + || hasTryAncestor(lastElement) + || MarimoUtils.isTreeInMarimoDecoratedFunction(lastElement, ctx); } // ignore jumps in try statement because CFG is not precise diff --git a/python-checks/src/main/java/org/sonar/python/checks/ReferencedBeforeAssignmentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ReferencedBeforeAssignmentCheck.java index 92bcde0bb3..c5384be0f9 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ReferencedBeforeAssignmentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ReferencedBeforeAssignmentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -47,7 +47,7 @@ public void initialize(Context context) { if (TreeUtils.hasDescendant(functionDef, tree -> tree.is(Tree.Kind.TRY_STMT))) { return; } - ControlFlowGraph cfg = ControlFlowGraph.build(functionDef, ctx.pythonFile()); + ControlFlowGraph cfg = ctx.cfg(functionDef); if (cfg == null) { return; } diff --git a/python-checks/src/main/java/org/sonar/python/checks/ReturnAndYieldInOneFunctionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ReturnAndYieldInOneFunctionCheck.java index 9995852379..1c7cab7edc 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ReturnAndYieldInOneFunctionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ReturnAndYieldInOneFunctionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -37,7 +37,7 @@ public void initialize(Context context) { func.body().accept(returnAndYieldVisitor); if (returnAndYieldVisitor.hasYield && returnAndYieldVisitor.hasReturn) { - ctx.addIssue(func.name(), "Use only \"return\" or only \"yield\", not both."); + ctx.addIssue(func.name(), "Only yield or return values from this function, not both."); } }); } diff --git a/python-checks/src/main/java/org/sonar/python/checks/ReturnCheckUtils.java b/python-checks/src/main/java/org/sonar/python/checks/ReturnCheckUtils.java index 98b51fe03d..e311ace56b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ReturnCheckUtils.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ReturnCheckUtils.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/ReturnYieldOutsideFunctionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ReturnYieldOutsideFunctionCheck.java index cf8f3bf020..92f8b1238d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ReturnYieldOutsideFunctionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ReturnYieldOutsideFunctionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/RewriteCollectionConstructorAsComprehensionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/RewriteCollectionConstructorAsComprehensionCheck.java index c9351a9f31..8d46d2f5d7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/RewriteCollectionConstructorAsComprehensionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/RewriteCollectionConstructorAsComprehensionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/RobustCipherAlgorithmCheck.java b/python-checks/src/main/java/org/sonar/python/checks/RobustCipherAlgorithmCheck.java index cd603fa34d..c9a8e5575d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/RobustCipherAlgorithmCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/RobustCipherAlgorithmCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/RouterPrefixInIncludeRouterCheck.java b/python-checks/src/main/java/org/sonar/python/checks/RouterPrefixInIncludeRouterCheck.java index 38bc15a98a..848be1136c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/RouterPrefixInIncludeRouterCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/RouterPrefixInIncludeRouterCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SameBranchCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SameBranchCheck.java index 5500434590..8b5d73fa77 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SameBranchCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SameBranchCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SameConditionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SameConditionCheck.java index 0f7a5c24fa..d599b4b766 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SameConditionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SameConditionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SecureModeEncryptionAlgorithmsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SecureModeEncryptionAlgorithmsCheck.java index 482a72f2f7..839a457b24 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SecureModeEncryptionAlgorithmsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SecureModeEncryptionAlgorithmsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SelfAssignmentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SelfAssignmentCheck.java index 2485ff3160..0ddb1c7545 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SelfAssignmentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SelfAssignmentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SetDiscardOverRemoveCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SetDiscardOverRemoveCheck.java new file mode 100644 index 0000000000..81bd579aed --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/SetDiscardOverRemoveCheck.java @@ -0,0 +1,102 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.List; +import java.util.Optional; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ExpressionStatement; +import org.sonar.plugins.python.api.tree.IfStatement; +import org.sonar.plugins.python.api.tree.InExpression; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8492") +public class SetDiscardOverRemoveCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Use \"discard()\" instead of checking membership before calling \"remove()\"."; + private static final String QUICK_FIX_MESSAGE = "Replace with \"discard()\""; + private static final String REMOVE_METHOD_NAME = "remove"; + private static final TypeMatcher SET_TYPE_MATCHER = TypeMatchers.isObjectInstanceOf("builtins.set"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.IF_STMT, SetDiscardOverRemoveCheck::checkIfStatement); + } + + private static void checkIfStatement(SubscriptionContext ctx) { + IfStatement ifStatement = (IfStatement) ctx.syntaxNode(); + if (ifStatement.isElif() + || ifStatement.elseBranch() != null + || !ifStatement.elifBranches().isEmpty()) { + return; + } + if (!(ifStatement.condition() instanceof InExpression inExpression) || inExpression.notToken() != null) { + return; + } + List statements = ifStatement.body().statements(); + if (statements.size() != 1 || !(statements.get(0) instanceof ExpressionStatement expressionStatement)) { + return; + } + if (expressionStatement.expressions().size() != 1 + || !(expressionStatement.expressions().get(0) instanceof CallExpression callExpression)) { + return; + } + if (!(callExpression.callee() instanceof QualifiedExpression qualifiedExpression) + || !REMOVE_METHOD_NAME.equals(qualifiedExpression.name().name())) { + return; + } + List arguments = callExpression.arguments(); + if (arguments.size() != 1 || !(arguments.get(0) instanceof RegularArgument regularArgument) + || regularArgument.keywordArgument() != null) { + return; + } + if (!CheckUtils.areEquivalent(qualifiedExpression.qualifier(), inExpression.rightOperand()) + || !CheckUtils.areEquivalent(regularArgument.expression(), inExpression.leftOperand())) { + return; + } + if (!SET_TYPE_MATCHER.isTrueFor(qualifiedExpression.qualifier(), ctx)) { + return; + } + var issue = ctx.addIssue(inExpression, MESSAGE); + createQuickFix(ifStatement, qualifiedExpression, regularArgument).ifPresent(issue::addQuickFix); + } + + private static Optional createQuickFix(IfStatement ifStatement, QualifiedExpression qualifiedExpression, RegularArgument argument) { + String qualifierText = TreeUtils.treeToString(qualifiedExpression.qualifier(), false); + String argumentText = TreeUtils.treeToString(argument.expression(), false); + if (qualifierText == null || argumentText == null) { + return Optional.empty(); + } + String replacement = "%s.discard(%s)".formatted(qualifierText, argumentText); + return Optional.of(PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.replace(ifStatement, replacement)) + .build()); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/SetDuplicateKeyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SetDuplicateKeyCheck.java index 0628b93665..0849d78974 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SetDuplicateKeyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SetDuplicateKeyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SetUpdateOverForLoopCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SetUpdateOverForLoopCheck.java new file mode 100644 index 0000000000..3059173a94 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/SetUpdateOverForLoopCheck.java @@ -0,0 +1,142 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionStatement; +import org.sonar.plugins.python.api.tree.ForStatement; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.UnpackingExpression; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8502") +public class SetUpdateOverForLoopCheck extends PythonSubscriptionCheck { + + private static final TypeMatcher SET_TYPE_MATCHER = TypeMatchers.isObjectOfType("builtins.set"); + + private static final String MESSAGE = "Use \"set.update()\" instead of a for-loop with \"add()\"."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FOR_STMT, SetUpdateOverForLoopCheck::checkForStatement); + } + + private static void checkForStatement(SubscriptionContext ctx) { + ForStatement forStatement = (ForStatement) ctx.syntaxNode(); + + if (forStatement.expressions().size() != 1) { + return; + } + if (forStatement.elseClause() != null) { + return; + } + Expression loopVarExpr = forStatement.expressions().get(0); + if (!(loopVarExpr instanceof Name loopVar)) { + return; + } + if (forStatement.testExpressions().size() != 1) { + return; + } + Expression iterable = forStatement.testExpressions().get(0); + + CallExpression callExpr = extractSingleBodyCallExpression(forStatement); + if (callExpr == null) { + return; + } + if (!(callExpr.callee() instanceof QualifiedExpression qualifiedExpr)) { + return; + } + // TypeMatchers operate on types, not method names; the callee name must be checked syntactically + if (!"add".equals(qualifiedExpr.name().name())) { + return; + } + Expression receiver = qualifiedExpr.qualifier(); + + // Exclude transient objects like get_set().add(item) + if (receiver instanceof CallExpression) { + return; + } + if (!SET_TYPE_MATCHER.isTrueFor(receiver, ctx)) { + return; + } + if (!isLoopVariableTheOnlyArgument(callExpr, loopVar)) { + return; + } + + PreciseIssue issue = ctx.addIssue(qualifiedExpr, MESSAGE); + addQuickFix(issue, forStatement, receiver, iterable); + } + + private static boolean isLoopVariableTheOnlyArgument(CallExpression callExpr, Name loopVar) { + if (callExpr.arguments().size() != 1) { + return false; + } + if (!(callExpr.arguments().get(0) instanceof RegularArgument regularArgument)) { + return false; + } + if (regularArgument.keywordArgument() != null) { + return false; + } + Expression argExpr = regularArgument.expression(); + if (argExpr instanceof UnpackingExpression || !(argExpr instanceof Name argName)) { + return false; + } + SymbolV2 loopVarSymbol = loopVar.symbolV2(); + return loopVarSymbol != null && loopVarSymbol.equals(argName.symbolV2()); + } + + private static CallExpression extractSingleBodyCallExpression(ForStatement forStatement) { + if (forStatement.body().statements().size() != 1) { + return null; + } + if (!(forStatement.body().statements().get(0) instanceof ExpressionStatement exprStmt)) { + return null; + } + if (exprStmt.expressions().size() != 1) { + return null; + } + if (!(exprStmt.expressions().get(0) instanceof CallExpression callExpr)) { + return null; + } + return callExpr; + } + + private static void addQuickFix(PreciseIssue issue, ForStatement forStatement, Expression receiver, Expression iterable) { + String receiverText = TreeUtils.treeToString(receiver, false); + String iterableText = TreeUtils.treeToString(iterable, false); + if (receiverText == null || iterableText == null) { + return; + } + + String replacement = receiverText + ".update(" + iterableText + ")"; + + PythonQuickFix quickFix = PythonQuickFix.newQuickFix("Use \"set.update()\" instead", TextEditUtils.replace(forStatement, replacement)); + issue.addQuickFix(quickFix); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/SideEffectInTfFunctionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SideEffectInTfFunctionCheck.java index af5fc494f0..b07ecc78d3 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SideEffectInTfFunctionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SideEffectInTfFunctionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SillyEquality.java b/python-checks/src/main/java/org/sonar/python/checks/SillyEquality.java index fe843c35ea..c6f6777a77 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SillyEquality.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SillyEquality.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SillyEqualityCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SillyEqualityCheck.java index aa2114435e..093491a562 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SillyEqualityCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SillyEqualityCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SillyIdentityCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SillyIdentityCheck.java index 6b0e72c21e..d88ebc296d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SillyIdentityCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SillyIdentityCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SingleDispatchMixupCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SingleDispatchMixupCheck.java new file mode 100644 index 0000000000..cd2ddfab1b --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/SingleDispatchMixupCheck.java @@ -0,0 +1,77 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S8505") +public class SingleDispatchMixupCheck extends PythonSubscriptionCheck { + + private static final TypeMatcher SINGLEDISPATCH_MATCHER = TypeMatchers.isType("functools.singledispatch"); + private static final TypeMatcher SINGLEDISPATCHMETHOD_MATCHER = TypeMatchers.isType("functools.singledispatchmethod"); + private static final TypeMatcher STATICMETHOD_MATCHER = TypeMatchers.isType("builtins.staticmethod"); + + private static final String MSG_USE_SINGLEDISPATCHMETHOD = + "Use \"@singledispatchmethod\" instead of \"@singledispatch\" on methods defined in a class body."; + private static final String MSG_USE_SINGLEDISPATCH = + "Use \"@singledispatch\" instead of \"@singledispatchmethod\" on standalone functions."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, SingleDispatchMixupCheck::checkFunctionDef); + } + + private static void checkFunctionDef(SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + List decorators = functionDef.decorators(); + if (decorators.isEmpty()) { + return; + } + + boolean isMethod = functionDef.isMethodDefinition(); + + for (int i = 0; i < decorators.size(); i++) { + Decorator decorator = decorators.get(i); + if (SINGLEDISPATCH_MATCHER.isTrueFor(decorator.expression(), ctx)) { + // @singledispatch on a method is broken: dispatch happens on self's/cls's type. + // The only valid combination on a method is @staticmethod applied as an outer decorator + if (isMethod && !isWrappedByOuterStaticmethod(decorators, i, ctx)) { + ctx.addIssue(decorator, MSG_USE_SINGLEDISPATCHMETHOD); + } + } else if (SINGLEDISPATCHMETHOD_MATCHER.isTrueFor(decorator.expression(), ctx) && !isMethod) { + ctx.addIssue(decorator, MSG_USE_SINGLEDISPATCH); + } + } + } + + private static boolean isWrappedByOuterStaticmethod(List decorators, int innerIndex, SubscriptionContext ctx) { + for (int i = 0; i < innerIndex; i++) { + if (STATICMETHOD_MATCHER.isTrueFor(decorators.get(i).expression(), ctx)) { + return true; + } + } + return false; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/SkLearnEstimatorDontInitializeEstimatedValuesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SkLearnEstimatorDontInitializeEstimatedValuesCheck.java index 0587549430..35cdde102d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SkLearnEstimatorDontInitializeEstimatedValuesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SkLearnEstimatorDontInitializeEstimatedValuesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SklearnCachedPipelineDontAccessTransformersCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SklearnCachedPipelineDontAccessTransformersCheck.java index 8d1fed1e62..bfa1d8a374 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SklearnCachedPipelineDontAccessTransformersCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SklearnCachedPipelineDontAccessTransformersCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -26,7 +26,7 @@ import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.quickfix.PythonQuickFix; -import org.sonar.plugins.python.api.symbols.Symbol; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.ListLiteral; @@ -35,10 +35,12 @@ import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.StringLiteral; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.UnknownType; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.quickfix.TextEditUtils; import org.sonar.python.tree.TreeUtils; import org.sonar.python.tree.TupleImpl; -import org.sonar.python.types.InferredTypes; import static org.sonar.python.checks.utils.Expressions.getAssignedName; @@ -48,6 +50,8 @@ public class SklearnCachedPipelineDontAccessTransformersCheck extends PythonSubs public static final String MESSAGE = "Avoid accessing transformers in a cached pipeline."; public static final String MESSAGE_SECONDARY = "The transformer is accessed here"; public static final String MESSAGE_SECONDARY_CREATION = "The Pipeline is created here"; + private static final TypeMatcher IS_PIPELINE = TypeMatchers.isType("sklearn.pipeline.Pipeline"); + private static final TypeMatcher IS_MAKE_PIPELINE = TypeMatchers.isType("sklearn.pipeline.make_pipeline"); @Override public void initialize(Context context) { @@ -56,14 +60,16 @@ public void initialize(Context context) { private static void checkCallExpr(SubscriptionContext subscriptionContext) { CallExpression callExpression = (CallExpression) subscriptionContext.syntaxNode(); - Optional pipelineCreationOptional = isPipelineCreation(callExpression); + Optional pipelineCreationOptional = isPipelineCreation(callExpression, subscriptionContext); if (pipelineCreationOptional.isEmpty()) { return; } PipelineCreation pipelineCreation = pipelineCreationOptional.get(); var memoryArgument = TreeUtils.argumentByKeyword("memory", callExpression.arguments()); - if (memoryArgument == null || memoryArgument.expression().is(Tree.Kind.NONE) || memoryArgument.expression().type() == InferredTypes.anyType()) { + if (memoryArgument == null || + memoryArgument.expression().is(Tree.Kind.NONE) || + memoryArgument.expression().typeV2() instanceof UnknownType) { return; } var stepsArgument = TreeUtils.nthArgumentOrKeyword(0, "steps", callExpression.arguments()); @@ -149,7 +155,7 @@ private static Optional getQuickFix(Name pipelineBindingVariable } private static Map symbolIsUsedInQualifiedExpression(Name name) { - Symbol symbol = name.symbol(); + SymbolV2 symbol = name.symbolV2(); if (symbol == null) { return new HashMap<>(); } @@ -166,16 +172,13 @@ private enum PipelineCreation { MAKE_PIPELINE } - private static Optional isPipelineCreation(CallExpression callExpression) { - return Optional.ofNullable(callExpression.calleeSymbol()).map(Symbol::fullyQualifiedName) - .map(fqn -> { - if ("sklearn.pipeline.Pipeline".equals(fqn)) { - return PipelineCreation.PIPELINE; - } - if ("sklearn.pipeline.make_pipeline".equals(fqn)) { - return PipelineCreation.MAKE_PIPELINE; - } - return null; - }); + private static Optional isPipelineCreation(CallExpression callExpression, SubscriptionContext ctx) { + if (IS_PIPELINE.isTrueFor(callExpression.callee(), ctx)) { + return Optional.of(PipelineCreation.PIPELINE); + } + if (IS_MAKE_PIPELINE.isTrueFor(callExpression.callee(), ctx)) { + return Optional.of(PipelineCreation.MAKE_PIPELINE); + } + return Optional.empty(); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/SklearnPipelineParameterAreCorrectCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SklearnPipelineParameterAreCorrectCheck.java index 14c5531fb9..5a8a3fc543 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SklearnPipelineParameterAreCorrectCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SklearnPipelineParameterAreCorrectCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SklearnPipelineSpecifyMemoryArgumentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SklearnPipelineSpecifyMemoryArgumentCheck.java index e802ccf558..2938fda826 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SklearnPipelineSpecifyMemoryArgumentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SklearnPipelineSpecifyMemoryArgumentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SleepZeroInAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SleepZeroInAsyncCheck.java index 1e4987eae4..7c16ecf349 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SleepZeroInAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SleepZeroInAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SlotsAssignmentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SlotsAssignmentCheck.java new file mode 100644 index 0000000000..ce22cfa90a --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/SlotsAssignmentCheck.java @@ -0,0 +1,371 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.BaseTreeVisitor; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.CompoundAssignmentStatement; +import org.sonar.plugins.python.api.tree.DictionaryLiteral; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.KeyValuePair; +import org.sonar.plugins.python.api.tree.ListLiteral; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Parameter; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.SetLiteral; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.Tuple; +import org.sonar.plugins.python.api.types.BuiltinTypes; +import org.sonar.plugins.python.api.types.v2.ClassType; +import org.sonar.plugins.python.api.types.v2.FunctionType; +import org.sonar.plugins.python.api.types.v2.PythonType; +import org.sonar.plugins.python.api.types.v2.TypeWrapper; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8494") +public class SlotsAssignmentCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Add \"%s\" to the class's \"__slots__\"."; + + /** + * Built-in C types whose instances don't have __dict__ by default. + * When subclassing these, __slots__ restrictions still apply even though + * we can't find a ClassDef to inspect. + */ + private static final Set BUILTIN_TYPES_WITHOUT_DICT = Set.of( + BuiltinTypes.INT, BuiltinTypes.FLOAT, BuiltinTypes.COMPLEX, + BuiltinTypes.STR, BuiltinTypes.BYTES, + BuiltinTypes.BOOL, BuiltinTypes.LIST, BuiltinTypes.TUPLE, + BuiltinTypes.SET, BuiltinTypes.DICT, BuiltinTypes.NONE_TYPE, + "type", "frozenset", "memoryview", "bytearray", "range"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, SlotsAssignmentCheck::checkClass); + } + + private static void checkClass(SubscriptionContext ctx) { + ClassDef classDef = (ClassDef) ctx.syntaxNode(); + PythonType classType = classDef.name().typeV2(); + if (!(classType instanceof ClassType classTypeV2)) { + return; + } + + // Find __slots__ assignment in this class body + Set ownSlots = extractOwnSlots(classDef); + if (ownSlots == null) { + // No __slots__ found or dynamic/unsupported form + return; + } + + if (ownSlots.contains("__dict__")) { + // Explicit opt-out: __dict__ in slots means no restriction + return; + } + + if (classTypeV2.hasUnresolvedHierarchy()) { + // Can't safely analyze hierarchy + return; + } + + // Build allowed slots: own + ancestors + Set allowedSlots = new HashSet<>(ownSlots); + Set visited = new HashSet<>(); + if (!collectAncestorSlots(classTypeV2, classDef, allowedSlots, visited)) { + // Some resolvable parent has no __slots__, so __dict__ is available + return; + } + + // Check each instance method + String className = classDef.name().name(); + for (FunctionDef functionDef : TreeUtils.topLevelFunctionDefs(classDef)) { + PythonType funcType = functionDef.name().typeV2(); + if (!(funcType instanceof FunctionType ft) || !ft.isInstanceMethod()) { + continue; + } + List params = TreeUtils.positionalParameters(functionDef); + if (!params.isEmpty()) { + String selfName = params.get(0).name().name(); + SelfAttributeAssignmentVisitor visitor = new SelfAttributeAssignmentVisitor(selfName, allowedSlots, className, ctx); + functionDef.body().accept(visitor); + } + } + } + + /** + * Extracts the slot names from the __slots__ assignment in the class body. + * Uses the last __slots__ assignment, since Python's class body executes top-to-bottom + * and the metaclass reads __slots__ from the final namespace value. + * Returns null if no __slots__ is found or if the form is not a supported literal. + * Returns an empty set if __slots__ = [] or __slots__ = (). + */ + @Nullable + private static Set extractOwnSlots(ClassDef classDef) { + Set result = null; + for (Statement stmt : classDef.body().statements()) { + if (stmt instanceof AssignmentStatement assignment) { + List lhsExpressions = assignment.lhsExpressions(); + if (lhsExpressions.size() == 1) { + List lhs = lhsExpressions.get(0).expressions(); + if (lhs.size() == 1 && lhs.get(0).is(Tree.Kind.NAME) && "__slots__".equals(((Name) lhs.get(0)).name())) { + // Found __slots__ assignment; keep iterating to use the last one + result = extractSlotNames(assignment.assignedValue()); + } + } + } + } + return result; + } + + /** + * Extracts slot names from the RHS of a __slots__ assignment. + * Returns null if the form is not a supported literal. + */ + @Nullable + private static Set extractSlotNames(Expression value) { + List elements; + if (value instanceof ListLiteral listLiteral) { + elements = listLiteral.elements().expressions(); + } else if (value instanceof Tuple tuple) { + elements = tuple.elements(); + } else if (value instanceof SetLiteral setLiteral) { + elements = setLiteral.elements(); + } else if (value instanceof DictionaryLiteral dictionaryLiteral) { + elements = extractDictKeys(dictionaryLiteral); + } else if (value instanceof StringLiteral stringLiteral) { + // Single string: __slots__ = 'attr_name' + return Set.of(stringLiteral.trimmedQuotesValue()); + } else { + // Dynamic or unsupported form + return null; + } + return elements != null ? extractStringLiterals(elements) : null; + } + + /** + * Extracts key expressions from a dictionary literal. + * Returns null if any element is not a KeyValuePair with a string key (e.g. unpacking). + */ + @Nullable + private static List extractDictKeys(DictionaryLiteral dictionaryLiteral) { + List keys = new ArrayList<>(); + for (Tree element : dictionaryLiteral.elements()) { + if (!(element instanceof KeyValuePair kvp)) { + return null; + } + keys.add(kvp.key()); + } + return keys; + } + + /** + * Collects trimmed string values from a list of expressions. + * If an element is a Name, attempts to resolve it to a StringLiteral via single-assignment analysis. + * Returns null if any element cannot be resolved to a string literal. + */ + @Nullable + private static Set extractStringLiterals(List elements) { + Set slots = new HashSet<>(); + for (Expression element : elements) { + if (element instanceof StringLiteral stringLiteral) { + slots.add(stringLiteral.trimmedQuotesValue()); + } else if (element instanceof Name name) { + Optional resolved = Expressions.singleAssignedNonNameValue(name); + if (resolved.isPresent() && resolved.get() instanceof StringLiteral stringLiteral) { + slots.add(stringLiteral.trimmedQuotesValue()); + } else { + return null; + } + } else { + return null; + } + } + return slots; + } + + /** + * Collects slot names from all ancestor classes into allowedSlots. + * Uses ClassType (v2) for type hierarchy filtering (FQN, object skipping) and + * resolves parent ClassDef AST nodes via SymbolV2's CLASS_DECLARATION usages. + * Returns false if any resolvable parent has no __slots__ (meaning __dict__ is available). + */ + private static boolean collectAncestorSlots(ClassType classType, ClassDef classDef, Set allowedSlots, + Set visited) { + for (TypeWrapper parentWrapper : classType.superClasses()) { + PythonType parentType = parentWrapper.type(); + if (!(parentType instanceof ClassType parentClassType) + || "object".equals(parentClassType.fullyQualifiedName()) + || !visited.add(parentClassType)) { + continue; + } + if (!processParentType(parentClassType, classDef, allowedSlots, visited)) { + return false; + } + } + return true; + } + + private static boolean processParentType(ClassType parentClassType, ClassDef classDef, Set allowedSlots, + Set visited) { + Optional parentClassDef = findParentClassDef(classDef, parentClassType); + if (parentClassDef.isEmpty()) { + // Can't inspect the parent's __slots__. Built-in C types don't provide __dict__ + // on their instances, so slots restrictions still apply when subclassing them. + // For all other types, we can't determine if __dict__ is available, so bail out. + String fqn = parentClassType.fullyQualifiedName(); + return fqn != null && BUILTIN_TYPES_WITHOUT_DICT.contains(fqn); + } + return processParentClass(parentClassDef.get(), allowedSlots, visited); + } + + private static Optional findParentClassDef(ClassDef childClassDef, ClassType parentClassType) { + if (childClassDef.args() == null) { + return Optional.empty(); + } + for (var arg : childClassDef.args().arguments()) { + if (arg instanceof RegularArgument regArg) { + Expression expr = regArg.expression(); + if (expr instanceof Name name && name.typeV2() == parentClassType) { + return findClassDefFromSymbolV2(name.symbolV2()); + } + } + } + return Optional.empty(); + } + + /** + * Finds the ClassDef AST node from a SymbolV2 by looking for its CLASS_DECLARATION usage. + */ + private static Optional findClassDefFromSymbolV2(@Nullable SymbolV2 symbolV2) { + if (symbolV2 == null) { + return Optional.empty(); + } + return symbolV2.usages().stream() + .filter(usage -> usage.kind() == UsageV2.Kind.CLASS_DECLARATION) + .map(usage -> TreeUtils.firstAncestorOfKind(usage.tree(), Tree.Kind.CLASSDEF)) + .filter(Objects::nonNull) + .map(ClassDef.class::cast) + .findFirst(); + } + + private static boolean processParentClass(ClassDef parentClassDef, Set allowedSlots, Set visited) { + Set parentSlots = extractOwnSlots(parentClassDef); + if (parentSlots == null || parentSlots.contains("__dict__")) { + return false; + } + + allowedSlots.addAll(parentSlots); + + PythonType parentType = parentClassDef.name().typeV2(); + if (!(parentType instanceof ClassType parentClassType)) { + return true; + } + return !parentClassType.hasUnresolvedHierarchy() && collectAncestorSlots(parentClassType, parentClassDef, allowedSlots, visited); + } + + private static class SelfAttributeAssignmentVisitor extends BaseTreeVisitor { + private final String selfName; + private final Set allowedSlots; + private final String className; + private final SubscriptionContext ctx; + + SelfAttributeAssignmentVisitor(String selfName, Set allowedSlots, String className, SubscriptionContext ctx) { + this.selfName = selfName; + this.allowedSlots = allowedSlots; + this.className = className; + this.ctx = ctx; + } + + @Override + public void visitAssignmentStatement(AssignmentStatement assignment) { + for (ExpressionList exprList : assignment.lhsExpressions()) { + for (Expression expr : exprList.expressions()) { + checkQualifiedExpression(expr); + } + } + // Do not call super to avoid visiting RHS as assignment targets + } + + @Override + public void visitCompoundAssignment(CompoundAssignmentStatement compoundAssignment) { + checkQualifiedExpression(compoundAssignment.lhsExpression()); + // Do not call super + } + + @Override + public void visitFunctionDef(FunctionDef functionDef) { + // Stop recursion into nested functions to avoid false positives + // where an inner function's first param shadows self + } + + @Override + public void visitClassDef(ClassDef classDef) { + // Stop recursion into nested classes to avoid false positives + } + + private void checkQualifiedExpression(Expression expr) { + if (!expr.is(Tree.Kind.QUALIFIED_EXPR)) { + return; + } + QualifiedExpression qualifiedExpr = (QualifiedExpression) expr; + Expression qualifier = qualifiedExpr.qualifier(); + if (!qualifier.is(Tree.Kind.NAME)) { + return; + } + if (!selfName.equals(((Name) qualifier).name())) { + return; + } + String attrName = qualifiedExpr.name().name(); + if (!allowedSlots.contains(attrName) && !allowedSlots.contains(mangledName(attrName))) { + ctx.addIssue(qualifiedExpr.name(), String.format(MESSAGE, attrName)); + } + } + + /** + * Returns the name-mangled form of a private attribute name within this class. + * Python mangles names starting with two underscores (but not ending with two underscores) + * by stripping leading underscores from the class name and prepending "_ClassName". + * For example, "__den" in class "_Rat" becomes "_Rat__den" (not "__Rat__den"). + * See: https://docs.python.org/3/reference/expressions.html#atom-identifiers + */ + private String mangledName(String attrName) { + if (attrName.startsWith("__") && !attrName.endsWith("__")) { + return "_" + className.replaceAll("^_+", "") + attrName; + } + return attrName; + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/SortedMinMaxCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SortedMinMaxCheck.java new file mode 100644 index 0000000000..9ca83a7a74 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/SortedMinMaxCheck.java @@ -0,0 +1,127 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.NumericLiteral; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.SubscriptionExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.UnaryExpression; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.hotspots.CommonValidationUtils; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8517") +public class SortedMinMaxCheck extends PythonSubscriptionCheck { + + private static final TypeMatcher IS_SORTED = TypeMatchers.isType("sorted"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.SUBSCRIPTION, SortedMinMaxCheck::check); + } + + private static void check(SubscriptionContext ctx) { + SubscriptionExpression subscriptionExpression = (SubscriptionExpression) ctx.syntaxNode(); + + if (subscriptionExpression.subscripts().expressions().size() != 1) { + return; + } + + Expression subscript = subscriptionExpression.subscripts().expressions().get(0); + Boolean isFirstElement = isIndexZeroOrMinusOne(subscript); + if (isFirstElement == null) { + return; + } + + Expression object = subscriptionExpression.object(); + if (!(object instanceof CallExpression callExpression)) { + return; + } + + if (!IS_SORTED.isTrueFor(callExpression.callee(), ctx)) { + return; + } + + Boolean isReversed = isReversed(callExpression); + if (isReversed == null) { + // Cannot determine reverse truthiness, skip to avoid wrong suggestions + return; + } + + String replacement = getReplacementFunction(isFirstElement, isReversed); + ctx.addIssue(subscriptionExpression, "Use \"" + replacement + "()\" instead of sorting to find this value."); + } + + /** + * Returns true if the expression is the integer literal 0 (first element), + * false if it is -1 (last element), or null if it is neither. + */ + @Nullable + private static Boolean isIndexZeroOrMinusOne(Expression subscript) { + if (subscript instanceof NumericLiteral numericLiteral && CommonValidationUtils.isEqualTo(numericLiteral, 0)) { + return true; + } + if (subscript instanceof UnaryExpression unaryExpression + && unaryExpression.is(Tree.Kind.UNARY_MINUS) + && unaryExpression.expression() instanceof NumericLiteral numericLiteral + && CommonValidationUtils.isEqualTo(numericLiteral, 1)) { + return false; + } + return null; + } + + /** + * Returns {@code Boolean.TRUE} if the reverse argument is truthy, {@code Boolean.FALSE} if it is absent or falsy, + * or {@code null} if the reverse argument is present but its truthiness cannot be determined. + */ + @Nullable + private static Boolean isReversed(CallExpression callExpression) { + RegularArgument reverseArg = TreeUtils.argumentByKeyword("reverse", callExpression.arguments()); + if (reverseArg == null) { + return Boolean.FALSE; + } + Expression value = reverseArg.expression(); + if (Expressions.isTruthy(value)) { + return Boolean.TRUE; + } + if (Expressions.isFalsy(value)) { + return Boolean.FALSE; + } + return null; + } + + private static String getReplacementFunction(boolean isFirstElement, boolean isReversed) { + // sorted()[0] -> min (smallest first without reverse) + // sorted()[-1] -> max (largest last without reverse) + // sorted(reverse=True)[0] -> max (largest first with reverse) + // sorted(reverse=True)[-1] -> min (smallest last with reverse) + if (isFirstElement) { + return isReversed ? "max" : "min"; + } else { + return isReversed ? "min" : "max"; + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/SpecialMethodParamListCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SpecialMethodParamListCheck.java index 40f0841d21..d0a467f3d1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SpecialMethodParamListCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SpecialMethodParamListCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SpecialMethodReturnTypeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SpecialMethodReturnTypeCheck.java index 2c1428828b..24b45c4c12 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SpecialMethodReturnTypeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SpecialMethodReturnTypeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/StartsWithEndsWithTupleCheck.java b/python-checks/src/main/java/org/sonar/python/checks/StartsWithEndsWithTupleCheck.java new file mode 100644 index 0000000000..988e30b520 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/StartsWithEndsWithTupleCheck.java @@ -0,0 +1,224 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.TriBool; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.BinaryExpression; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8513") +public class StartsWithEndsWithTupleCheck extends PythonSubscriptionCheck { + + private static final String STARTSWITH = "startswith"; + private static final String ENDSWITH = "endswith"; + + private static final TypeMatcher STR_BYTES_OR_BYTEARRAY_METHOD_MATCHER = TypeMatchers.isFunctionOwnerSatisfying( + TypeMatchers.any( + TypeMatchers.isOrExtendsType("builtins.str"), + TypeMatchers.isOrExtendsType("builtins.bytes"), + TypeMatchers.isOrExtendsType("builtins.bytearray"))); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.OR, StartsWithEndsWithTupleCheck::checkOrExpression); + } + + private static void checkOrExpression(SubscriptionContext ctx) { + BinaryExpression orExpr = (BinaryExpression) ctx.syntaxNode(); + Tree ancestor = orExpr.parent(); + while (ancestor instanceof Expression expr && Expressions.removeParentheses(expr) != expr) { + ancestor = ancestor.parent(); + } + if (ancestor != null && ancestor.is(Tree.Kind.OR)) { + return; + } + + List operands = flattenOrChain(orExpr); + if (operands.size() < 2) { + return; + } + + Optional> maybeCalls = extractCalls(operands, ctx); + if (maybeCalls.isEmpty()) { + return; + } + List calls = maybeCalls.get(); + + String methodName = extractUniformMethodName(calls); + if (methodName == null) { + return; + } + + if (!allSameReceiver(calls)) { + return; + } + + if (anyReceiverHasNestedCall(calls)) { + return; + } + + Optional> maybeArgTexts = extractStringLiteralArgs(calls); + if (maybeArgTexts.isEmpty()) { + return; + } + List argTexts = maybeArgTexts.get(); + + String message = String.format("Replace chained \"%s\" calls with a single call using a tuple argument.", methodName); + String receiverText = receiverSourceText(calls.get(0)); + if (receiverText == null) { + return; + } + String replacement = receiverText + "." + methodName + "((" + String.join(", ", argTexts) + "))"; + PythonQuickFix quickFix = PythonQuickFix.newQuickFix("Replace with a single call using a tuple argument", + TextEditUtils.replace(orExpr, replacement)); + ctx.addIssue(orExpr, message).addQuickFix(quickFix); + } + + private static List flattenOrChain(BinaryExpression orExpr) { + List result = new ArrayList<>(); + flattenOrChainInto(orExpr, result); + return result; + } + + private static void flattenOrChainInto(Expression expr, List result) { + Expression stripped = Expressions.removeParentheses(expr); + if (stripped.is(Tree.Kind.OR)) { + BinaryExpression binExpr = (BinaryExpression) stripped; + flattenOrChainInto(binExpr.leftOperand(), result); + flattenOrChainInto(binExpr.rightOperand(), result); + } else { + result.add(stripped); + } + } + + private static Optional> extractCalls(List operands, SubscriptionContext ctx) { + List calls = new ArrayList<>(); + for (Expression operand : operands) { + Expression stripped = Expressions.removeParentheses(operand); + if (!stripped.is(Tree.Kind.CALL_EXPR)) { + return Optional.empty(); + } + CallExpression call = (CallExpression) stripped; + if (!isStartsWithOrEndsWith(call, ctx)) { + return Optional.empty(); + } + calls.add(call); + } + return Optional.of(calls); + } + + private static boolean isStartsWithOrEndsWith(CallExpression call, SubscriptionContext ctx) { + if (!call.callee().is(Tree.Kind.QUALIFIED_EXPR)) { + return false; + } + QualifiedExpression callee = (QualifiedExpression) call.callee(); + String name = callee.name().name(); + if (!STARTSWITH.equals(name) && !ENDSWITH.equals(name)) { + return false; + } + return STR_BYTES_OR_BYTEARRAY_METHOD_MATCHER.evaluateFor(callee, ctx) != TriBool.FALSE; + } + + private static String extractUniformMethodName(List calls) { + String methodName = null; + for (CallExpression call : calls) { + QualifiedExpression callee = (QualifiedExpression) call.callee(); + String name = callee.name().name(); + if (methodName == null) { + methodName = name; + } else if (!methodName.equals(name)) { + return null; + } + } + return methodName; + } + + private static boolean allSameReceiver(List calls) { + Expression firstReceiver = getReceiver(calls.get(0)); + for (int i = 1; i < calls.size(); i++) { + Expression receiver = getReceiver(calls.get(i)); + if (!CheckUtils.areEquivalent(firstReceiver, receiver)) { + return false; + } + } + return true; + } + + private static Expression getReceiver(CallExpression call) { + return ((QualifiedExpression) call.callee()).qualifier(); + } + + private static boolean anyReceiverHasNestedCall(List calls) { + for (CallExpression call : calls) { + Expression receiver = getReceiver(call); + if (receiver.is(Tree.Kind.CALL_EXPR) || TreeUtils.hasDescendant(receiver, t -> t.is(Tree.Kind.CALL_EXPR))) { + return true; + } + } + return false; + } + + private static Optional> extractStringLiteralArgs(List calls) { + List argTexts = new ArrayList<>(); + for (CallExpression call : calls) { + List args = call.arguments(); + if (args.size() != 1) { + return Optional.empty(); + } + Argument arg = args.get(0); + if (!(arg instanceof RegularArgument regularArg)) { + return Optional.empty(); + } + if (regularArg.keywordArgument() != null) { + return Optional.empty(); + } + Expression argExpr = regularArg.expression(); + if (!argExpr.is(Tree.Kind.STRING_LITERAL)) { + return Optional.empty(); + } + String argSource = TreeUtils.treeToString(argExpr, false); + if (argSource == null) { + return Optional.empty(); + } + argTexts.add(argSource); + } + return Optional.of(argTexts); + } + + private static String receiverSourceText(CallExpression call) { + Expression receiver = getReceiver(call); + return TreeUtils.treeToString(receiver, false); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/StopIterationInGeneratorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/StopIterationInGeneratorCheck.java new file mode 100644 index 0000000000..04caf18400 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/StopIterationInGeneratorCheck.java @@ -0,0 +1,63 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.RaiseStatement; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8493") +public class StopIterationInGeneratorCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Replace this \"raise StopIteration\" with a \"return\" statement."; + + private final TypeMatcher stopIterationMatcher = TypeMatchers.any( + TypeMatchers.isObjectOfType("StopIteration"), + TypeMatchers.isType("StopIteration") + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.RAISE_STMT, this::checkRaise); + } + + private void checkRaise(SubscriptionContext ctx) { + RaiseStatement raiseStatement = (RaiseStatement) ctx.syntaxNode(); + if (raiseStatement.expressions().isEmpty()) { + return; + } + Expression expression = raiseStatement.expressions().get(0); + if (!stopIterationMatcher.isTrueFor(expression, ctx)) { + return; + } + FunctionDef enclosingFunction = (FunctionDef) TreeUtils.firstAncestorOfKind(raiseStatement, Tree.Kind.FUNCDEF); + if (enclosingFunction == null) { + return; + } + if (!ReturnCheckUtils.ReturnStmtCollector.collect(enclosingFunction).containsYield()) { + return; + } + ctx.addIssue(raiseStatement, MESSAGE); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/StrftimeConfusingHourSystemCheck.java b/python-checks/src/main/java/org/sonar/python/checks/StrftimeConfusingHourSystemCheck.java index 665a3d5dcf..052802c92c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/StrftimeConfusingHourSystemCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/StrftimeConfusingHourSystemCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -19,12 +19,13 @@ import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.StringLiteral; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; @@ -34,6 +35,7 @@ public class StrftimeConfusingHourSystemCheck extends PythonSubscriptionCheck { public static final String MESSAGE = "Use %I (12-hour clock) or %H (24-hour clock) without %p (AM/PM)."; public static final String MESSAGE_12_HOURS = "Use %I (12-hour clock) with %p (AM/PM)."; private static final String MESSAGE_SECONDARY_LOCATION = "Wrong format created here."; + private static final TypeMatcher STRFTIME_MATCHER = TypeMatchers.isType("datetime.time.strftime"); @Override public void initialize(Context context) { @@ -70,12 +72,7 @@ private static void checkDateFormatStringLiteral(SubscriptionContext context, Tr private static void checkCallExpr(SubscriptionContext context) { CallExpression callExpression = (CallExpression) context.syntaxNode(); - Symbol calleeSymbol = callExpression.calleeSymbol(); - if (calleeSymbol == null) { - return; - } - String fullyQualifiedName = calleeSymbol.fullyQualifiedName(); - if (!"datetime.time.strftime".equals(fullyQualifiedName)) { + if (!STRFTIME_MATCHER.isTrueFor(callExpression.callee(), context)) { return; } diff --git a/python-checks/src/main/java/org/sonar/python/checks/StringFormat.java b/python-checks/src/main/java/org/sonar/python/checks/StringFormat.java index 27bd3e33c3..353c714de8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/StringFormat.java +++ b/python-checks/src/main/java/org/sonar/python/checks/StringFormat.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/StringFormatCorrectnessCheck.java b/python-checks/src/main/java/org/sonar/python/checks/StringFormatCorrectnessCheck.java index 654b422980..905f62b0eb 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/StringFormatCorrectnessCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/StringFormatCorrectnessCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -20,19 +20,25 @@ import java.util.HashSet; import java.util.List; import java.util.Locale; +import java.util.Objects; import java.util.Optional; import java.util.Set; import java.util.stream.IntStream; import org.sonar.check.Rule; import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.symbols.Symbol; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.plugins.python.api.tree.ArgList; import org.sonar.plugins.python.api.tree.BinaryExpression; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.DictionaryLiteral; import org.sonar.plugins.python.api.tree.DictionaryLiteralElement; import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; import org.sonar.plugins.python.api.tree.KeyValuePair; import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Parameter; import org.sonar.plugins.python.api.tree.QualifiedExpression; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.StringElement; @@ -40,10 +46,14 @@ import org.sonar.plugins.python.api.tree.Token; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.MarimoUtils; +import org.sonar.python.tree.TreeUtils; @Rule(key = "S3457") public class StringFormatCorrectnessCheck extends AbstractStringFormatCheck { + private static final TypeMatcher MARIMO_SQL_MATCHER = TypeMatchers.isType("marimo.sql"); + private static final Set LOGGER_FULL_NAMES = new HashSet<>(Arrays.asList( "logging.debug", "logging.info", "logging.warning", "logging.error", "logging.critical", "logging.Logger.debug", "logging.Logger.info", "logging.Logger.warning", "logging.Logger.error", "logging.Logger.critical" @@ -114,11 +124,58 @@ private static void checkFStringLiteral(SubscriptionContext ctx) { .filter(stringElement -> stringElement.prefix().toLowerCase(Locale.ENGLISH).contains("f")) .toList(); - if (!fStrings.isEmpty() && fStrings.stream().allMatch(str -> str.formattedExpressions().isEmpty())) { + if (!fStrings.isEmpty() && fStrings.stream().allMatch(str -> str.formattedExpressions().isEmpty()) + && !isMarimoSqlArgument(literal, ctx)) { ctx.addIssue(literal, "Add replacement fields or use a normal string instead of an f-string."); } } + private static boolean isMarimoSqlArgument(StringLiteral literal, SubscriptionContext ctx) { + return enclosingCallExpression(literal) + .filter(callExpression -> MARIMO_SQL_MATCHER.isTrueFor(callExpression.callee(), ctx) + || isInjectedMarimoSqlCall(callExpression, literal, ctx)) + .isPresent(); + } + + private static Optional enclosingCallExpression(StringLiteral literal) { + Tree parent = literal.parent(); + if (!(parent instanceof RegularArgument)) { + return Optional.empty(); + } + Tree argList = parent.parent(); + if (!(argList instanceof ArgList)) { + return Optional.empty(); + } + Tree callParent = argList.parent(); + if (!(callParent instanceof CallExpression callExpression)) { + return Optional.empty(); + } + return Optional.of(callExpression); + } + + private static boolean isInjectedMarimoSqlCall(CallExpression callExpression, StringLiteral literal, SubscriptionContext ctx) { + if (!isMoSqlCall(callExpression) || !MarimoUtils.isTreeInMarimoCell(literal, ctx)) { + return false; + } + return Optional.ofNullable(TreeUtils.firstAncestorOfClass(literal, FunctionDef.class)) + .map(FunctionDef::parameters) + .stream() + .flatMap(parameters -> parameters.nonTuple().stream()) + .map(Parameter::name) + .filter(Objects::nonNull) + .anyMatch(name -> "mo".equals(name.name())); + } + + private static boolean isMoSqlCall(CallExpression callExpression) { + if (!(callExpression.callee() instanceof QualifiedExpression qualifiedExpression)) { + return false; + } + if (!"sql".equals(qualifiedExpression.name().name())) { + return false; + } + return qualifiedExpression.qualifier() instanceof Name qualifier && "mo".equals(qualifier.name()); + } + private static void checkLoggerLog(SubscriptionContext ctx, CallExpression callExpression) { if (callExpression.arguments().isEmpty() || callExpression.arguments().stream().anyMatch(argument -> !argument.is(Tree.Kind.REGULAR_ARGUMENT))) { return; diff --git a/python-checks/src/main/java/org/sonar/python/checks/StringFormatMisuseCheck.java b/python-checks/src/main/java/org/sonar/python/checks/StringFormatMisuseCheck.java index b171e10460..c17692dab9 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/StringFormatMisuseCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/StringFormatMisuseCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/StringLiteralDuplicationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/StringLiteralDuplicationCheck.java index b5c2cabc8d..e133da84ea 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/StringLiteralDuplicationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/StringLiteralDuplicationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -35,6 +35,7 @@ import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.TypeAnnotation; import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.GeneratedFileUtils; import org.sonar.python.tree.TreeUtils; @Rule(key = "S1192") @@ -85,7 +86,8 @@ private Optional customExclusionPattern() { public void visitFileInput(FileInput fileInput) { literalsByValue.clear(); - if (this.getContext().pythonFile().fileName().startsWith("test")) { + if (this.getContext().pythonFile().fileName().startsWith("test") + || GeneratedFileUtils.isGeneratedFileForReadabilityRules(this.getContext().pythonFile(), fileInput)) { return; } super.visitFileInput(fileInput); diff --git a/python-checks/src/main/java/org/sonar/python/checks/SumListConcatenationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SumListConcatenationCheck.java new file mode 100644 index 0000000000..11fc05e277 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/SumListConcatenationCheck.java @@ -0,0 +1,63 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ListLiteral; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8520") +public class SumListConcatenationCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Use \"itertools.chain.from_iterable()\" instead of \"sum()\" to flatten or concatenate lists."; + private static final TypeMatcher SUM_MATCHER = TypeMatchers.isType("sum"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, SumListConcatenationCheck::checkCall); + } + + private static void checkCall(SubscriptionContext ctx) { + CallExpression call = (CallExpression) ctx.syntaxNode(); + if (!SUM_MATCHER.isTrueFor(call.callee(), ctx)) { + return; + } + RegularArgument startArgument = TreeUtils.nthArgumentOrKeyword(1, "start", call.arguments()); + if (isEmptyListLiteral(startArgument)) { + ctx.addIssue(call, MESSAGE); + } + } + + private static boolean isEmptyListLiteral(@Nullable RegularArgument argument) { + if (argument == null) { + return false; + } + if (!argument.expression().is(Tree.Kind.LIST_LITERAL)) { + return false; + } + ListLiteral listLiteral = (ListLiteral) argument.expression(); + return listLiteral.elements().expressions().isEmpty(); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/SynchronousFileOperationsInAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SynchronousFileOperationsInAsyncCheck.java index 26f5ae20a7..c11833493b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SynchronousFileOperationsInAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SynchronousFileOperationsInAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SynchronousHttpOperationsInAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SynchronousHttpOperationsInAsyncCheck.java index a1619c7f69..9a41132aaa 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SynchronousHttpOperationsInAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SynchronousHttpOperationsInAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SynchronousOsCallsInAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SynchronousOsCallsInAsyncCheck.java index 2ae58ed3cf..33df01860a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SynchronousOsCallsInAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SynchronousOsCallsInAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/SynchronousSubprocessOperationsInAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/SynchronousSubprocessOperationsInAsyncCheck.java index 6b2ce4a60c..e47195214b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/SynchronousSubprocessOperationsInAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/SynchronousSubprocessOperationsInAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TaskGroupNurseryUsedOnlyOnceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TaskGroupNurseryUsedOnlyOnceCheck.java index dfc33cfdc2..bdd70248a6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TaskGroupNurseryUsedOnlyOnceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TaskGroupNurseryUsedOnlyOnceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TempFileCreationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TempFileCreationCheck.java index 84e110fcb2..1481f7a6e0 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TempFileCreationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TempFileCreationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,34 +16,38 @@ */ package org.sonar.python.checks; -import java.util.Arrays; -import java.util.List; import java.util.Optional; -import javax.annotation.Nullable; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.plugins.python.api.symbols.Symbol; +import org.sonar.plugins.python.api.types.v2.FullyQualifiedNameHelper; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; @Rule(key = "S5445") public class TempFileCreationCheck extends PythonSubscriptionCheck { - private static final List SUSPICIOUS_CALLS = Arrays.asList("os.tempnam", "os.tmpnam", "tempfile.mktemp"); + // os.tempnam and os.tmpnam were removed in Python 3 and have no stubs. + // We use withFQN to match both qualified (os.tempnam) and direct import (from os import tempnam) forms, + // as the callee gets typed as UnresolvedImportType("os.tempnam") in both cases. + private static final TypeMatcher INSECURE_CALLS = TypeMatchers.any( + TypeMatchers.isType("tempfile.mktemp"), + TypeMatchers.withFQN("os.tempnam"), + TypeMatchers.withFQN("os.tmpnam") + ); @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { - CallExpression callExpr = (CallExpression) ctx.syntaxNode(); - Symbol symbol = callExpr.calleeSymbol(); - isInsecureTempFile(symbol).ifPresent(s -> ctx.addIssue(callExpr, String.format("'%s' is insecure. Use 'tempfile.TemporaryFile' instead", s))); - }); + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, TempFileCreationCheck::checkCallExpression); } - private static Optional isInsecureTempFile(@Nullable Symbol symbol) { - if (symbol == null) { - return Optional.empty(); - } - return SUSPICIOUS_CALLS.stream().filter(call -> call.equals(symbol.fullyQualifiedName())).findFirst(); + private static void checkCallExpression(SubscriptionContext ctx) { + CallExpression callExpr = (CallExpression) ctx.syntaxNode(); + Optional.of(callExpr.callee()) + .filter(callee -> INSECURE_CALLS.isTrueFor(callee, ctx)) + .flatMap(callee -> FullyQualifiedNameHelper.getFullyQualifiedName(callee.typeV2())) + .ifPresent(name -> ctx.addIssue(callExpr.callee(), String.format("'%s' is insecure. Use 'tempfile.TemporaryFile' instead", name))); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/TemplateAndStrConcatenationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TemplateAndStrConcatenationCheck.java index d7e2c35255..bdcc1b81ea 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TemplateAndStrConcatenationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TemplateAndStrConcatenationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TemplateStringStructuralPatternMatchingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TemplateStringStructuralPatternMatchingCheck.java index ed81df4634..904ad0c474 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TemplateStringStructuralPatternMatchingCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TemplateStringStructuralPatternMatchingCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TestClientContentParameterCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TestClientContentParameterCheck.java index 1f15136e29..623af28b4b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TestClientContentParameterCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TestClientContentParameterCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -43,7 +43,9 @@ public class TestClientContentParameterCheck extends PythonSubscriptionCheck { .map(name -> STARLETTE_TEST_CLIENT_FQN + "." + name) .map(TypeMatchers::isType)); - private static final TypeMatcher IS_STRING = TypeMatchers.isObjectOfType("str"); + private static final TypeMatcher IS_STRING_OR_BYTES = TypeMatchers.any( + TypeMatchers.isObjectOfType("str"), + TypeMatchers.isObjectOfType("bytes")); @Override public CheckScope scope() { @@ -83,6 +85,6 @@ private static boolean isTestClientHttpMethodCall(CallExpression call, Subscript } private static boolean isBytesOrStrLiteral(Expression expr, SubscriptionContext ctx) { - return IS_STRING.isTrueFor(expr, ctx); + return IS_STRING_OR_BYTES.isTrueFor(expr, ctx); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/TfFunctionDependOnOutsideVariableCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TfFunctionDependOnOutsideVariableCheck.java index f16aaea792..2103731149 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TfFunctionDependOnOutsideVariableCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TfFunctionDependOnOutsideVariableCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TfFunctionRecursivityCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TfFunctionRecursivityCheck.java index 907522e6f9..d093b5cde6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TfFunctionRecursivityCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TfFunctionRecursivityCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TfGatherDeprecatedValidateIndicesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TfGatherDeprecatedValidateIndicesCheck.java index 1d60178ded..a67000fe73 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TfGatherDeprecatedValidateIndicesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TfGatherDeprecatedValidateIndicesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TfInputShapeOnModelSubclassCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TfInputShapeOnModelSubclassCheck.java index 1cbced79a3..6b30e2ac25 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TfInputShapeOnModelSubclassCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TfInputShapeOnModelSubclassCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TfPyTorchSpecifyReductionAxisCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TfPyTorchSpecifyReductionAxisCheck.java index deaaae5857..4f37ab1a57 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TfPyTorchSpecifyReductionAxisCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TfPyTorchSpecifyReductionAxisCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TimeSleepInAsyncCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TimeSleepInAsyncCheck.java index 9020a22777..b8546d3c3c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TimeSleepInAsyncCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TimeSleepInAsyncCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TimezoneNaiveDatetimeConstructorsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TimezoneNaiveDatetimeConstructorsCheck.java index 1bb28be3ea..938833f083 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TimezoneNaiveDatetimeConstructorsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TimezoneNaiveDatetimeConstructorsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,18 +16,22 @@ */ package org.sonar.python.checks; -import java.util.Set; +import java.util.Optional; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.FullyQualifiedNameHelper; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; @Rule(key = "S6903") public class TimezoneNaiveDatetimeConstructorsCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Don't use `%s` to create this datetime object."; - private static final Set NON_COMPLIANT_FQNS = Set.of("datetime.datetime.utcnow", "datetime.datetime.utcfromtimestamp"); + private static final TypeMatcher NON_COMPLIANT_MATCHER = TypeMatchers.any( + TypeMatchers.isType("datetime.datetime.utcnow"), + TypeMatchers.isType("datetime.datetime.utcfromtimestamp")); @Override public void initialize(Context context) { @@ -36,15 +40,9 @@ public void initialize(Context context) { private static void checkCallExpr(SubscriptionContext context) { CallExpression callExpression = (CallExpression) context.syntaxNode(); - Symbol calleeSymbol = callExpression.calleeSymbol(); - - if (calleeSymbol == null) { - return; - } - String fullyQualifiedName = calleeSymbol.fullyQualifiedName(); - if (fullyQualifiedName == null || !NON_COMPLIANT_FQNS.contains(fullyQualifiedName)) { - return; - } - context.addIssue(callExpression, String.format(MESSAGE, fullyQualifiedName)); + Optional.of(callExpression.callee()) + .filter(callee -> NON_COMPLIANT_MATCHER.isTrueFor(callee, context)) + .flatMap(callee -> FullyQualifiedNameHelper.getFullyQualifiedName(callee.typeV2())) + .ifPresent(fqn -> context.addIssue(callExpression.callee(), String.format(MESSAGE, fqn))); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/ToDoCommentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/ToDoCommentCheck.java index 33d596b0a5..547144c983 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/ToDoCommentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/ToDoCommentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TooManyLinesInFileCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TooManyLinesInFileCheck.java index d3f34f823b..65a5a74b2b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TooManyLinesInFileCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TooManyLinesInFileCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TooManyLinesInFunctionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TooManyLinesInFunctionCheck.java index 2079528716..637f721888 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TooManyLinesInFunctionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TooManyLinesInFunctionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TooManyParametersCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TooManyParametersCheck.java index 95ef7ca04d..4ac1484d55 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TooManyParametersCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TooManyParametersCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TooManyReturnsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TooManyReturnsCheck.java index d672d339ed..825e2070e5 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TooManyReturnsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TooManyReturnsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TorchAutogradVariableShouldNotBeUsedCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TorchAutogradVariableShouldNotBeUsedCheck.java index e2fdec94d5..d596d5319a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TorchAutogradVariableShouldNotBeUsedCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TorchAutogradVariableShouldNotBeUsedCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -18,21 +18,22 @@ import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; -import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; @Rule(key = "S6979") public class TorchAutogradVariableShouldNotBeUsedCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Replace this call with a call to \"torch.tensor\"."; - private static final String TORCH_AUTOGRAD_VARIABLE = "torch.autograd.Variable"; + // torch.autograd.Variable has no stubs, so the type resolves as UnresolvedImportType. Use withFQN to match on the FQN directly. + private static final TypeMatcher TORCH_AUTOGRAD_VARIABLE = TypeMatchers.withFQN("torch.autograd.Variable"); @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { CallExpression callExpression = (CallExpression) ctx.syntaxNode(); - Symbol calleeSymbol = callExpression.calleeSymbol(); - if (calleeSymbol != null && TORCH_AUTOGRAD_VARIABLE.equals(calleeSymbol.fullyQualifiedName())) { + if (TORCH_AUTOGRAD_VARIABLE.isTrueFor(callExpression.callee(), ctx)) { ctx.addIssue(callExpression.callee(), MESSAGE); } }); diff --git a/python-checks/src/main/java/org/sonar/python/checks/TorchLoadLeadsToUntrustedCodeExecutionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TorchLoadLeadsToUntrustedCodeExecutionCheck.java index ca4a452a40..5607f58d93 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TorchLoadLeadsToUntrustedCodeExecutionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TorchLoadLeadsToUntrustedCodeExecutionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -20,6 +20,7 @@ import java.util.Set; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.Argument; import org.sonar.plugins.python.api.tree.CallExpression; @@ -27,7 +28,6 @@ import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.cfg.fixpoint.ReachingDefinitionsAnalysis; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; @@ -39,39 +39,33 @@ public class TorchLoadLeadsToUntrustedCodeExecutionCheck extends PythonSubscript public static final String PYTHON_FALSE = "False"; public static final String WEIGHTS_ONLY = "weights_only"; - private ReachingDefinitionsAnalysis reachingDefinitionsAnalysis; - @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> reachingDefinitionsAnalysis = - new ReachingDefinitionsAnalysis(ctx.pythonFile())); - context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { CallExpression callExpression = (CallExpression) ctx.syntaxNode(); Symbol calleeSymbol = callExpression.calleeSymbol(); if (calleeSymbol != null && TORCH_LOAD.equals(calleeSymbol.fullyQualifiedName()) - && isWeightsOnlyNotFoundOrSetToFalse(callExpression.arguments())) { + && isWeightsOnlyNotFoundOrSetToFalse(callExpression.arguments(), ctx)) { ctx.addIssue(callExpression.callee(), MESSAGE); } }); } - private boolean isWeightsOnlyNotFoundOrSetToFalse(List arguments) { + private static boolean isWeightsOnlyNotFoundOrSetToFalse(List arguments, SubscriptionContext ctx) { RegularArgument weightsOnlyArg = TreeUtils.argumentByKeyword(WEIGHTS_ONLY, arguments); if (weightsOnlyArg == null) return !Expressions.containsSpreadOperator(arguments); if (weightsOnlyArg.expression() instanceof Name name) { - return PYTHON_FALSE.equals(name.name()) || isNameSetToFalse(name); + return PYTHON_FALSE.equals(name.name()) || isNameSetToFalse(name, ctx); } return false; } - private boolean isNameSetToFalse(Name name) { - Set values = reachingDefinitionsAnalysis.valuesAtLocation(name); + private static boolean isNameSetToFalse(Name name, SubscriptionContext ctx) { + Set values = ctx.valuesAtLocation(name); return values.size() == 1 && values.stream() .flatMap(TreeUtils.toStreamInstanceOfMapper(Name.class)) .map(Name::name).allMatch(PYTHON_FALSE::equals); } - } diff --git a/python-checks/src/main/java/org/sonar/python/checks/TorchModuleModeShouldBeSetAfterLoadingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TorchModuleModeShouldBeSetAfterLoadingCheck.java index cc0cc20f0a..2a232325d8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TorchModuleModeShouldBeSetAfterLoadingCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TorchModuleModeShouldBeSetAfterLoadingCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TorchModuleShouldCallInitCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TorchModuleShouldCallInitCheck.java index 3e945cfa58..9e28e51cdb 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TorchModuleShouldCallInitCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TorchModuleShouldCallInitCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TrailingCommentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TrailingCommentCheck.java index 8a7d0eab82..f8714a753a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TrailingCommentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TrailingCommentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TrailingWhitespaceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TrailingWhitespaceCheck.java index 57f27edfe0..cc0621038f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TrailingWhitespaceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TrailingWhitespaceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TypeAliasAnnotationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TypeAliasAnnotationCheck.java index 4feb678f26..456cafbe96 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/TypeAliasAnnotationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/TypeAliasAnnotationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/TypeVarCovariantAndContravariantCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TypeVarCovariantAndContravariantCheck.java new file mode 100644 index 0000000000..392174d5b2 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/TypeVarCovariantAndContravariantCheck.java @@ -0,0 +1,61 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8515") +public class TypeVarCovariantAndContravariantCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove either \"covariant=True\" or \"contravariant=True\"; a TypeVar cannot be both covariant and contravariant."; + private static final TypeMatcher TYPEVAR_MATCHER = TypeMatchers.any( + TypeMatchers.isType("typing.TypeVar"), + TypeMatchers.isType("typing_extensions.TypeVar") + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, TypeVarCovariantAndContravariantCheck::checkTypeVarCall); + } + + private static void checkTypeVarCall(SubscriptionContext ctx) { + CallExpression call = (CallExpression) ctx.syntaxNode(); + if (!TYPEVAR_MATCHER.isTrueFor(call.callee(), ctx)) { + return; + } + RegularArgument covariantArg = TreeUtils.argumentByKeyword("covariant", call.arguments()); + if (covariantArg == null) { + return; + } + RegularArgument contravariantArg = TreeUtils.argumentByKeyword("contravariant", call.arguments()); + if (contravariantArg == null) { + return; + } + if (Expressions.isTruthy(covariantArg.expression()) && Expressions.isTruthy(contravariantArg.expression())) { + ctx.addIssue(call.callee(), MESSAGE); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/TypeVarNamingConventionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/TypeVarNamingConventionCheck.java new file mode 100644 index 0000000000..adca3049d7 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/TypeVarNamingConventionCheck.java @@ -0,0 +1,84 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8507") +public class TypeVarNamingConventionCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Rename this string to match the variable name \"%s\"."; + + private static final TypeMatcher TYPING_CONSTRUCT_MATCHER = TypeMatchers.any( + TypeMatchers.isType("typing.TypeVar"), + TypeMatchers.isType("typing_extensions.TypeVar"), + TypeMatchers.isType("typing.ParamSpec"), + TypeMatchers.isType("typing_extensions.ParamSpec"), + TypeMatchers.isType("typing.NewType"), + TypeMatchers.isType("typing_extensions.NewType") + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, TypeVarNamingConventionCheck::checkCall); + } + + private static void checkCall(SubscriptionContext ctx) { + CallExpression call = (CallExpression) ctx.syntaxNode(); + if (!TYPING_CONSTRUCT_MATCHER.isTrueFor(call.callee(), ctx)) { + return; + } + RegularArgument firstArg = TreeUtils.nthArgumentOrKeyword(0, "name", call.arguments()); + if (firstArg == null || !firstArg.expression().is(Tree.Kind.STRING_LITERAL)) { + return; + } + StringLiteral stringLiteral = (StringLiteral) firstArg.expression(); + String stringName = stringLiteral.trimmedQuotesValue(); + + Tree parent = call.parent(); + if (!(parent instanceof AssignmentStatement assignment)) { + return; + } + if (assignment.lhsExpressions().size() != 1) { + return; + } + ExpressionList lhsExprList = assignment.lhsExpressions().get(0); + if (lhsExprList.expressions().size() != 1) { + return; + } + Tree lhsExpr = lhsExprList.expressions().get(0); + if (!lhsExpr.is(Tree.Kind.NAME)) { + return; + } + String variableName = ((Name) lhsExpr).name(); + if (!stringName.equals(variableName)) { + ctx.addIssue(stringLiteral, String.format(MESSAGE, variableName)); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/UndefinedNameAllPropertyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UndefinedNameAllPropertyCheck.java index eee61c42d3..3fd3f8e56c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UndefinedNameAllPropertyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UndefinedNameAllPropertyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UndefinedSymbolsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UndefinedSymbolsCheck.java index 3c1ab068b1..609432b8e2 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UndefinedSymbolsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UndefinedSymbolsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -31,7 +31,9 @@ import org.sonar.plugins.python.api.tree.ImportFrom; import org.sonar.plugins.python.api.tree.Name; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.TypeAliasStatement; import org.sonar.plugins.python.api.tree.TypeParams; +import org.sonar.python.semantic.BuiltinSymbols; import org.sonar.python.tree.TreeUtils; @Rule(key = "S5953") @@ -72,19 +74,22 @@ private static class UnresolvedSymbolsVisitor extends BaseTreeVisitor { @Override public void visitName(Name name) { - if (name.isVariable() && name.symbol() == null && !name.name().startsWith("_") && !isTypeVar(name)) { + if (name.isVariable() && name.symbolV2() == null && !BuiltinSymbols.all().contains(name.name()) && !name.name().startsWith("_") && !isTypeVar(name)) { nameIssues.computeIfAbsent(name.name(), k -> new ArrayList<>()).add(name); } } private static boolean isTypeVar(Name name) { - return TreeUtils.firstAncestor(name, tree -> classWithTypeVar(tree, name)) != null; + return TreeUtils.firstAncestor(name, tree -> hasTypeVarInScope(tree, name)) != null; } - private static boolean classWithTypeVar(Tree tree, Name name) { + private static boolean hasTypeVarInScope(Tree tree, Name name) { if (tree instanceof ClassDef classDef) { return hasTypeVar(classDef.typeParams(), name); } + if (tree instanceof TypeAliasStatement typeAliasStatement) { + return hasTypeVar(typeAliasStatement.typeParams(), name); + } return false; } diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnionTypeExpressionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnionTypeExpressionCheck.java index bde31892a5..08db91d5d5 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnionTypeExpressionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnionTypeExpressionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,6 +16,7 @@ */ package org.sonar.python.checks; +import java.util.function.Predicate; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.PythonVersionUtils; @@ -23,13 +24,15 @@ import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.TypeAnnotation; -import org.sonar.plugins.python.api.types.InferredType; -import org.sonar.python.types.InferredTypes; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; @Rule(key = "S6546") public class UnionTypeExpressionCheck extends PythonSubscriptionCheck { private static final String MESSAGE = "Use a union type expression for this type hint."; + private static final TypeMatcher TYPING_UNION_MATCHER = TypeMatchers.isType("typing.Union"); @Override public void initialize(Context context) { @@ -45,13 +48,9 @@ private static void checkTypeAnnotation(SubscriptionContext ctx) { TypeAnnotation typeAnnotation = (TypeAnnotation) ctx.syntaxNode(); Expression expression = typeAnnotation.expression(); - if (expression.is(Tree.Kind.BITWISE_OR)) { - return; - } - InferredType type = InferredTypes.fromTypeAnnotation(typeAnnotation); - String fqn = InferredTypes.fullyQualifiedTypeName(type); - if ("typing.Union".equals(fqn)) { + Predicate isUnionName = n -> n.is(Tree.Kind.NAME) && TYPING_UNION_MATCHER.isTrueFor((Expression) n, ctx); + if (isUnionName.test(expression) || TreeUtils.hasDescendant(expression, isUnionName)) { ctx.addIssue(expression, MESSAGE); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryComprehensionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryComprehensionCheck.java index e486786c6a..2518314a48 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryComprehensionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryComprehensionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryLambdaMapCallCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryLambdaMapCallCheck.java index 81e0961e79..69fdb0d69a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryLambdaMapCallCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryLambdaMapCallCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryListCastCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryListCastCheck.java index 2ecfd747e7..3a5aac7ae7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryListCastCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryListCastCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryListComprehensionArgumentCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryListComprehensionArgumentCheck.java index 55927f183e..1603fffbf6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryListComprehensionArgumentCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryListComprehensionArgumentCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryReversedCallCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryReversedCallCheck.java index 6e6f6ac972..15a59850d6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryReversedCallCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnnecessaryReversedCallCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnnecessarySortInsideSetCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnnecessarySortInsideSetCheck.java index 92f382b2b7..7483635801 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnnecessarySortInsideSetCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnnecessarySortInsideSetCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnnecessarySubscriptReversalCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnnecessarySubscriptReversalCheck.java index f277aef66d..234c8d422a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnnecessarySubscriptReversalCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnnecessarySubscriptReversalCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -88,15 +88,19 @@ private boolean isSensitiveCall(CallExpression callExpression) { } private static boolean isSubscriptReversal(@Nullable Tree expression) { - return expression instanceof SliceExpression sliceExpression - && sliceExpression.sliceList().slices().size() == 1 - && sliceExpression.sliceList().slices().get(0) instanceof SliceItem sliceItem - && sliceItem.lowerBound() == null - && sliceItem.upperBound() == null - && sliceItem.stride() instanceof UnaryExpression unaryExpression - && unaryExpression.is(Tree.Kind.UNARY_MINUS) - && unaryExpression.expression() instanceof NumericLiteral numericLiteral - && numericLiteral.valueAsLong() == 1; + try { + return expression instanceof SliceExpression sliceExpression + && sliceExpression.sliceList().slices().size() == 1 + && sliceExpression.sliceList().slices().get(0) instanceof SliceItem sliceItem + && sliceItem.lowerBound() == null + && sliceItem.upperBound() == null + && sliceItem.stride() instanceof UnaryExpression unaryExpression + && unaryExpression.is(Tree.Kind.UNARY_MINUS) + && unaryExpression.expression() instanceof NumericLiteral numericLiteral + && numericLiteral.valueAsLong() == 1; + } catch (NumberFormatException nfe) { + return false; + } } private static int getUsageCount(Name name) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnprocessedTemplateStringCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnprocessedTemplateStringCheck.java index 81701bf4ec..3a43649fc0 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnprocessedTemplateStringCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnprocessedTemplateStringCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnreachableExceptCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnreachableExceptCheck.java index e351674ca2..2f7d4c0494 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnreachableExceptCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnreachableExceptCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateAttributesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateAttributesCheck.java index 42d44e42f3..21eef223c2 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateAttributesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateAttributesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateInnerClassesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateInnerClassesCheck.java index d795173b90..44f4b3c862 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateInnerClassesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateInnerClassesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateMethodsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateMethodsCheck.java index bd8069435b..9457d2b510 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateMethodsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnreadPrivateMethodsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnusedFunctionParameterCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnusedFunctionParameterCheck.java index ba90c7ee49..d04a682a1d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnusedFunctionParameterCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnusedFunctionParameterCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -41,6 +41,8 @@ import org.sonar.plugins.python.api.tree.Token; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.Tree.Kind; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.plugins.python.api.tree.Trivia; import org.sonar.python.checks.utils.CheckUtils; import org.sonar.python.checks.utils.StringLiteralValuesCollector; @@ -57,6 +59,12 @@ public class UnusedFunctionParameterCheck extends PythonSubscriptionCheck { private static final Set AWS_LAMBDA_PARAMETERS = Set.of("event", "context"); + private static final Set DJANGO_MIDDLEWARE_METHODS = Set.of( + "process_request", "process_exception", "process_view", "process_template_response"); + + private static final TypeMatcher MIDDLEWARE_MIXIN_MATCHER = TypeMatchers.isFunctionOwnerSatisfying( + TypeMatchers.isOrExtendsType("django.utils.deprecation.MiddlewareMixin")); + @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Kind.FUNCDEF, ctx -> checkFunctionParameter(ctx, ((FunctionDef) ctx.syntaxNode()))); @@ -119,6 +127,7 @@ private static boolean isException(SubscriptionContext ctx, FunctionDef function hasNonCallUsages(functionSymbol) || isTestFunction(ctx, functionDef) || isDjangoView(functionDef) || + isDjangoMiddlewareFunction(ctx, functionDef) || isAbstractClass(functionDef); } @@ -201,4 +210,13 @@ private static boolean isDjangoView(FunctionDef functionDef) { FunctionSymbolImpl functionSymbolImpl = (FunctionSymbolImpl) functionSymbol; return functionSymbolImpl != null && functionSymbolImpl.isDjangoView(); } + + + private static boolean isDjangoMiddlewareFunction(SubscriptionContext ctx, FunctionDef functionDef) { + String functionName = functionDef.name().name(); + if (!DJANGO_MIDDLEWARE_METHODS.contains(functionName)) { + return false; + } + return MIDDLEWARE_MIXIN_MATCHER.isTrueFor(functionDef.name(), ctx); + } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnusedImportCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnusedImportCheck.java index ea76bbd79c..85cd443d0e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnusedImportCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnusedImportCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnusedLocalVariableCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnusedLocalVariableCheck.java index ca2e03fbea..f5c8b34faa 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnusedLocalVariableCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnusedLocalVariableCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UnusedNestedDefinitionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UnusedNestedDefinitionCheck.java index 66d40de3ec..1f64b80db1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UnusedNestedDefinitionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UnusedNestedDefinitionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UseOfAnyAsTypeHintCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UseOfAnyAsTypeHintCheck.java index f3376927e6..d552669e7d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UseOfAnyAsTypeHintCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UseOfAnyAsTypeHintCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -26,6 +26,7 @@ import org.sonar.plugins.python.api.tree.Decorator; import org.sonar.plugins.python.api.tree.FunctionDef; import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Parameter; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.TypeAnnotation; import org.sonar.python.semantic.SymbolUtils; @@ -55,12 +56,20 @@ private static void checkForAnyInReturnTypeAndParameters(SubscriptionContext ctx TypeAnnotation typeAnnotation = (TypeAnnotation) ctx.syntaxNode(); Optional.of(typeAnnotation) .filter(UseOfAnyAsTypeHintCheck::isTypeAny) + .filter(Predicate.not(UseOfAnyAsTypeHintCheck::isVariadicParameter)) .map(annotation -> (FunctionDef) TreeUtils.firstAncestorOfKind(annotation, Tree.Kind.FUNCDEF)) .filter(Predicate.not(UseOfAnyAsTypeHintCheck::hasFunctionOverrideOrOverloadDecorator)) .filter(Predicate.not(UseOfAnyAsTypeHintCheck::canFunctionBeAnOverride)) .ifPresent(functionDef -> ctx.addIssue(typeAnnotation.expression(), MESSAGE)); } + private static boolean isVariadicParameter(TypeAnnotation typeAnnotation) { + return Optional.ofNullable(typeAnnotation.parent()) + .flatMap(TreeUtils.toOptionalInstanceOfMapper(Parameter.class)) + .map(Parameter::starToken) + .isPresent(); + } + private static boolean isTypeAny(@Nullable TypeAnnotation typeAnnotation) { return Optional.ofNullable(typeAnnotation) .map(TypeAnnotation::expression) diff --git a/python-checks/src/main/java/org/sonar/python/checks/UseOfEmptyReturnValueCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UseOfEmptyReturnValueCheck.java index f109147066..7e944d8dc0 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UseOfEmptyReturnValueCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UseOfEmptyReturnValueCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UseStartsWithEndsWithCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UseStartsWithEndsWithCheck.java index 38f74e675c..19c30d8538 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UseStartsWithEndsWithCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UseStartsWithEndsWithCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -123,9 +123,7 @@ private static SliceType fromSliceItem(SliceItem sliceItem) { // then we don't check the rule. if (stride != null && !stride.type().mustBeOrExtend(BuiltinTypes.NONE_TYPE) && - !(stride.is(Tree.Kind.NUMERIC_LITERAL) && - stride.type().mustBeOrExtend(BuiltinTypes.INT) && - ((NumericLiteral) stride).valueAsLong() == 1)) { + !isIntLiteralEqualTo(stride, 1)) { return SliceType.COMPLEX; } @@ -153,6 +151,16 @@ private static boolean isEmptyBound(@CheckForNull Expression bound) { } } + private static boolean isIntLiteralEqualTo(Expression expression, long expected) { + try { + return expression.is(Tree.Kind.NUMERIC_LITERAL) + && expression.type().mustBeOrExtend(BuiltinTypes.INT) + && ((NumericLiteral) expression).valueAsLong() == expected; + } catch (NumberFormatException nfe) { + return false; + } + } + private enum OperatorType { EQUALS, NOT_EQUALS, diff --git a/python-checks/src/main/java/org/sonar/python/checks/UselessParenthesisAfterKeywordCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UselessParenthesisAfterKeywordCheck.java index 5076d46eb5..b1b707a6db 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UselessParenthesisAfterKeywordCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UselessParenthesisAfterKeywordCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UselessParenthesisCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UselessParenthesisCheck.java index d4d711239a..0a6a578e6d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UselessParenthesisCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UselessParenthesisCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/UselessStatementCheck.java b/python-checks/src/main/java/org/sonar/python/checks/UselessStatementCheck.java index e4870edd89..04ae5e784b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/UselessStatementCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/UselessStatementCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -17,24 +17,23 @@ package org.sonar.python.checks; import java.util.Arrays; -import java.util.HashSet; import java.util.List; -import java.util.Objects; import java.util.Optional; -import java.util.Set; import java.util.stream.Stream; import org.sonar.check.Rule; import org.sonar.check.RuleProperty; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.symbols.ClassSymbol; -import org.sonar.plugins.python.api.symbols.FunctionSymbol; -import org.sonar.plugins.python.api.symbols.Symbol; -import org.sonar.plugins.python.api.symbols.Usage; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.types.v2.FunctionType; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.plugins.python.api.tree.BinaryExpression; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.ClassDef; import org.sonar.plugins.python.api.tree.ConditionalExpression; +import org.sonar.plugins.python.api.tree.Decorator; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.FileInput; import org.sonar.plugins.python.api.tree.FunctionDef; @@ -48,6 +47,7 @@ import org.sonar.plugins.python.api.tree.UnaryExpression; import org.sonar.plugins.python.api.tree.WithItem; import org.sonar.plugins.python.api.tree.WithStatement; +import org.sonar.python.checks.utils.MarimoUtils; import org.sonar.python.tree.TreeUtils; @Rule(key = "S905") @@ -87,10 +87,22 @@ private List ignoredOperators() { private static final List unaryExpressionKinds = Arrays.asList(Kind.UNARY_PLUS, Kind.UNARY_MINUS, Kind.BITWISE_COMPLEMENT, Kind.NOT); - private static final Set ignoredContexts = new HashSet<>(List.of("contextlib.suppress")); - private static final String MESSAGE = "Remove or refactor this statement; it has no side effects."; + private static final TypeMatcher EXCEPTION_CLASS_TYPE_MATCHER = TypeMatchers.isOrExtendsType("builtins.BaseException"); + + private static final TypeMatcher CONTEXTLIB_SUPPRESS_TYPE_MATCHER = TypeMatchers.isType("contextlib.suppress"); + + private static final TypeMatcher AIRFLOW_TYPE_MATCHER = TypeMatchers.any( + TypeMatchers.isObjectInstanceOf("airflow.models.baseoperator.BaseOperator"), + TypeMatchers.isObjectInstanceOf("airflow.models.dag.DAG"), + TypeMatchers.isObjectInstanceOf("airflow.models.taskmixin.DependencyMixin") + ); + + private static final TypeMatcher DAG_CLASS_TYPE_MATCHER = TypeMatchers.isType("airflow.models.dag.DAG"); + + private static final TypeMatcher DAG_DECORATOR_TYPE_MATCHER = TypeMatchers.isType("airflow.decorators.dag"); + @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Kind.STRING_LITERAL, this::checkStringLiteral); @@ -118,56 +130,79 @@ private static void checkNode(SubscriptionContext ctx) { if (parent == null || !parent.is(Kind.EXPRESSION_STMT)) { return; } - if (isWithinIgnoredContext(tree)) { + if (isWithinIgnoredContext(tree, ctx)) { return; } // Safe cast because the rule only subscribes to expressions - if (isAnAirflowException((Expression) tree)) { + if (isAnAirflowException((Expression) tree, ctx)) { + return; + } + if (isAMarimoException((Expression) tree, ctx)) { return; } ctx.addIssue(tree, MESSAGE); } - private static boolean isAnAirflowException(Expression expression) { - if (isWithinAirflowContext(expression)) { + private static boolean isAnAirflowException(Expression expression, SubscriptionContext ctx) { + if (isWithinAirflowContext(expression, ctx)) { StatementList statementList = (StatementList) TreeUtils.firstAncestorOfKind(expression, Kind.STATEMENT_LIST); - return Optional.ofNullable(statementList).map(StatementList::statements).map(statements -> statements.get(statements.size() - 1)) + return Optional.ofNullable(statementList) + .map(StatementList::statements) + .map(statements -> statements.get(statements.size() - 1)) .filter(lastStatement -> lastStatement.equals(TreeUtils.firstAncestorOfKind(expression, Kind.EXPRESSION_STMT))).isPresent(); } return false; } - private static boolean isWithinIgnoredContext(Tree tree) { + private static boolean isAMarimoException(Expression expression, SubscriptionContext ctx) { + return MarimoUtils.isTreeInMarimoCell(expression, ctx) && isLastExpressionInFunction(expression); + } + + private static boolean isLastExpressionInFunction(Expression expr) { + FunctionDef functionDef = TreeUtils.firstAncestorOfClass(expr, FunctionDef.class); + if (functionDef == null) { + return false; + } + StatementList statementList = functionDef.body(); + + Tree expressionStmt = TreeUtils.firstAncestorOfKind(expr, Kind.EXPRESSION_STMT); + return statementList.statements().stream() + .filter(s -> s.is(Kind.EXPRESSION_STMT)) + .reduce((first, second) -> second) + .filter(lastExprStmt -> lastExprStmt.equals(expressionStmt)) + .isPresent(); + } + + private static boolean isWithinIgnoredContext(Tree tree, SubscriptionContext ctx) { Tree withParent = TreeUtils.firstAncestorOfKind(tree, Kind.WITH_STMT); if (withParent != null) { WithStatement withStatement = (WithStatement) withParent; return withStatement.withItems().stream() .map(WithItem::test) .filter(item -> item.is(Kind.CALL_EXPR)) - .map(item -> ((CallExpression) item).calleeSymbol()) - .filter(Objects::nonNull) - .anyMatch(s -> ignoredContexts.contains(s.fullyQualifiedName())); + .map(item -> ((CallExpression) item).callee()) + .anyMatch(callee -> CONTEXTLIB_SUPPRESS_TYPE_MATCHER.isTrueFor(callee, ctx)); } return false; } - private static boolean isWithinAirflowContext(Tree tree) { + private static boolean isWithinAirflowContext(Tree tree, SubscriptionContext ctx) { Tree withParent = TreeUtils.firstAncestorOfKind(tree, Kind.WITH_STMT); while (withParent != null) { WithStatement withStatement = (WithStatement) withParent; if (withStatement.withItems().stream() .map(WithItem::test) .filter(item -> item.is(Kind.CALL_EXPR)) - .map(item -> ((CallExpression) item).calleeSymbol()) - .filter(Objects::nonNull) - .anyMatch(s -> "airflow.DAG".equals(s.fullyQualifiedName()))) { + .map(item -> ((CallExpression) item).callee()) + .anyMatch(callee -> DAG_CLASS_TYPE_MATCHER.isTrueFor(callee, ctx))) { return true; } withParent = TreeUtils.firstAncestorOfKind(withParent, Kind.WITH_STMT); } FunctionDef funcParent = (FunctionDef) TreeUtils.firstAncestorOfKind(tree, Kind.FUNCDEF); - return funcParent != null && funcParent.decorators().stream().map(deco -> TreeUtils.getSymbolFromTree(deco.expression())).filter(Optional::isPresent) - .anyMatch(symbol -> "airflow.decorators.dag".equals(symbol.get().fullyQualifiedName())); + return funcParent != null && funcParent.decorators().stream() + .map(Decorator::expression) + .anyMatch(expr -> DAG_DECORATOR_TYPE_MATCHER.isTrueFor(expr, ctx)); } private static boolean isBooleanExpressionWithCalls(Tree tree) { @@ -192,16 +227,16 @@ private void checkStringLiteral(SubscriptionContext ctx) { private static void checkName(SubscriptionContext ctx) { Name name = (Name) ctx.syntaxNode(); - Symbol symbol = name.symbol(); - if (symbol != null && symbol.is(Symbol.Kind.CLASS)) { - ClassSymbol classSymbol = (ClassSymbol) symbol; - // Creating an exception without raising it is covered by S3984 - if (classSymbol.canBeOrExtend("BaseException")) { - return; - } + // Creating an exception without raising it is covered by S3984 + if (EXCEPTION_CLASS_TYPE_MATCHER.isTrueFor(name, ctx)) { + return; + } + // Avoid raising on useless statements made to suppress issues due to "unused" import + SymbolV2 symbolV2 = name.symbolV2(); + if (symbolV2 != null && symbolV2.usages().stream().anyMatch(u -> u.kind() == UsageV2.Kind.IMPORT) && symbolV2.usages().size() == 2) { + return; } - if (symbol != null && symbol.usages().stream().anyMatch(u -> u.kind().equals(Usage.Kind.IMPORT)) && symbol.usages().size() == 2) { - // Avoid raising on useless statements made to suppress issues due to "unused" import + if (AIRFLOW_TYPE_MATCHER.isTrueFor(name, ctx)) { return; } checkNode(ctx); @@ -209,8 +244,8 @@ private static void checkName(SubscriptionContext ctx) { private static void checkQualifiedExpression(SubscriptionContext ctx) { QualifiedExpression qualifiedExpression = (QualifiedExpression) ctx.syntaxNode(); - Symbol symbol = qualifiedExpression.symbol(); - if (symbol != null && symbol.is(Symbol.Kind.FUNCTION) && ((FunctionSymbol) symbol).decorators().stream().noneMatch(d -> d.matches("property"))) { + // Only raise on functions; properties are already resolved to their return type by the type inference engine + if (qualifiedExpression.typeV2() instanceof FunctionType) { checkNode(ctx); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/VerifiedSslTlsCertificateCheck.java b/python-checks/src/main/java/org/sonar/python/checks/VerifiedSslTlsCertificateCheck.java index cad135a96c..e5b79ece42 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/VerifiedSslTlsCertificateCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/VerifiedSslTlsCertificateCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -433,7 +433,11 @@ private static boolean isFalsyRange(CallExpression callExpr, String fqn) { Expression firstArgExpr = regArg.expression(); if (firstArgExpr.is(Tree.Kind.NUMERIC_LITERAL)) { NumericLiteral num = (NumericLiteral) firstArgExpr; - return num.valueAsLong() == 0L; + try { + return num.valueAsLong() == 0L; + } catch (NumberFormatException nfe) { + return false; + } } } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/WeakSSLProtocolCheck.java b/python-checks/src/main/java/org/sonar/python/checks/WeakSSLProtocolCheck.java index f0362354d8..545b474f5a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/WeakSSLProtocolCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/WeakSSLProtocolCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/WebEntryPointDecoratorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/WebEntryPointDecoratorCheck.java index d0ddec7db0..1216f7739c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/WebEntryPointDecoratorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/WebEntryPointDecoratorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/WildcardImportCheck.java b/python-checks/src/main/java/org/sonar/python/checks/WildcardImportCheck.java index be5770528b..2486c2f139 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/WildcardImportCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/WildcardImportCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/WrongAssignmentOperatorCheck.java b/python-checks/src/main/java/org/sonar/python/checks/WrongAssignmentOperatorCheck.java index 6e80797c18..d5f6227092 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/WrongAssignmentOperatorCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/WrongAssignmentOperatorCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/XMLParserXXEVulnerableCheck.java b/python-checks/src/main/java/org/sonar/python/checks/XMLParserXXEVulnerableCheck.java index 79172f85e5..05bac5190b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/XMLParserXXEVulnerableCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/XMLParserXXEVulnerableCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractCdkResourceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractCdkResourceCheck.java index b4e707c033..cde6af2b8b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractCdkResourceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractCdkResourceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractIamPolicyStatementCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractIamPolicyStatementCheck.java index 4c855bcb05..7e65b41a2e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractIamPolicyStatementCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractIamPolicyStatementCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractS3BucketCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractS3BucketCheck.java index 5cc1382ae4..f6d7681278 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractS3BucketCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/AbstractS3BucketCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/CdkPredicate.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/CdkPredicate.java index ec73c2f581..31e2fcd277 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/CdkPredicate.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/CdkPredicate.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -194,7 +194,16 @@ private static boolean anyValueInInterval(Collection values, long min, lon } public static Predicate isNumeric(Set vals) { - return expression -> expression.is(Tree.Kind.NUMERIC_LITERAL) && vals.contains(((NumericLiteral) expression).valueAsLong()); + return expression -> { + if (!expression.is(Tree.Kind.NUMERIC_LITERAL)) { + return false; + } + try { + return vals.contains(((NumericLiteral) expression).valueAsLong()); + } catch (NumberFormatException nfe) { + return false; + } + }; } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/CdkUtils.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/CdkUtils.java index 2fd6099e7b..d56e6336b1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/CdkUtils.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/CdkUtils.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -55,7 +55,7 @@ private CdkUtils() { public static Optional getInt(Expression expression) { try { return Optional.of((int)((NumericLiteral) expression).valueAsLong()); - } catch (ClassCastException e) { + } catch (ClassCastException | NumberFormatException e) { return Optional.empty(); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/ClearTextProtocolsCheckPart.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/ClearTextProtocolsCheckPart.java index e4fbdd1729..d102baf431 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/ClearTextProtocolsCheckPart.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/ClearTextProtocolsCheckPart.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledEFSEncryptionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledEFSEncryptionCheck.java index 342f383453..aa32956b07 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledEFSEncryptionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledEFSEncryptionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledESDomainEncryptionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledESDomainEncryptionCheck.java index 047facd14e..1a2bb24be6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledESDomainEncryptionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledESDomainEncryptionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledRDSEncryptionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledRDSEncryptionCheck.java index 6aa23d3321..cfd48c6697 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledRDSEncryptionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledRDSEncryptionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledSNSTopicEncryptionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledSNSTopicEncryptionCheck.java index 0b324110ae..bcea7505ac 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledSNSTopicEncryptionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/DisabledSNSTopicEncryptionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/IamPolicyPublicAccessCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/IamPolicyPublicAccessCheck.java index b06445b95f..f7b9976af8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/IamPolicyPublicAccessCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/IamPolicyPublicAccessCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/IamPrivilegeEscalationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/IamPrivilegeEscalationCheck.java index e6e0be11ca..3e4de22b6a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/IamPrivilegeEscalationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/IamPrivilegeEscalationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/NetworkCallsWithoutTimeoutsInLambdaCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/NetworkCallsWithoutTimeoutsInLambdaCheck.java index 5778519ba8..a2eea81b4d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/NetworkCallsWithoutTimeoutsInLambdaCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/NetworkCallsWithoutTimeoutsInLambdaCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/PolicyStatement.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/PolicyStatement.java index 2d232ea7b0..9199e66d6a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/PolicyStatement.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/PolicyStatement.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/PrivilegePolicyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/PrivilegePolicyCheck.java index 00ee2556ad..d82af5b21f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/PrivilegePolicyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/PrivilegePolicyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/PublicApiIsSecuritySensitiveCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/PublicApiIsSecuritySensitiveCheck.java index 64f4c95859..57177a6483 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/PublicApiIsSecuritySensitiveCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/PublicApiIsSecuritySensitiveCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,105 +16,242 @@ */ package org.sonar.python.checks.cdk; -import java.util.HashSet; import java.util.List; +import java.util.Locale; import java.util.Optional; import java.util.Set; -import java.util.function.Predicate; +import javax.annotation.CheckForNull; import org.sonar.check.Rule; -import org.sonar.plugins.python.api.PythonVisitorContext; import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Expression; -import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.tree.FunctionDefImpl; -import org.sonar.python.tree.TreeUtils; +import org.sonar.python.checks.utils.Expressions; import static org.sonar.python.checks.cdk.CdkPredicate.isFqn; import static org.sonar.python.checks.cdk.CdkPredicate.isString; +import static org.sonar.python.checks.cdk.CdkPredicate.isStringLiteral; import static org.sonar.python.checks.cdk.CdkUtils.getArgument; -import static org.sonar.python.checks.cdk.CdkUtils.getDictionary; -import static org.sonar.python.checks.cdk.CdkUtils.getDictionaryPair; @Rule(key = "S6333") public class PublicApiIsSecuritySensitiveCheck extends AbstractCdkResourceCheck { - private static final String MESSAGE = "Make sure that creating public APIs is safe here."; - private static final String OMITTING_MESSAGE = "Omitting \"authorization_type\" disables authentication. Make sure it is safe here."; + + private static final String MESSAGE = "Ensure this API route requires authentication."; private static final String AUTHORIZATION_TYPE = "authorization_type"; + private static final String ENDPOINT_CONFIGURATION = "endpoint_configuration"; + private static final String TYPES = "types"; + private static final String HTTP_METHOD = "http_method"; + private static final String PATH_PART = "path_part"; private static final String AUTHORIZATION_TYPE_NONE = "aws_cdk.aws_apigateway.AuthorizationType.NONE"; + private static final String ADD_RESOURCE_FQN = "aws_cdk.aws_apigateway.Resource.add_resource"; + private static final String REST_API_FQN = "aws_cdk.aws_apigateway.RestApi"; + private static final String ENDPOINT_CONFIGURATION_FQN = "aws_cdk.aws_apigateway.EndpointConfiguration"; + private static final String ENDPOINT_TYPE_PRIVATE_FQN = "aws_cdk.aws_apigateway.EndpointType.PRIVATE"; - private final Set safeMethods = new HashSet<>(); + // Known public endpoints that do not require authentication by design. + private static final Set SAFE_PATH_NAMES = Set.of( + "login", "signup", "register", "authenticate", "token", + "forgot-password", "healthcheck", "health-check", "status", + "callback", "public-keys", "jwks", "well-known" + ); - @Override - public void scanFile(PythonVisitorContext visitorContext) { - super.scanFile(visitorContext); - safeMethods.clear(); - } + // Route names that are strong indicators of sensitive, access-controlled areas. + // Exact segment match only — "admin-portal" does not match "admin". + private static final Set SENSITIVE_PATH_NAMES = Set.of( + "admin", "management", "internal" + ); + + private static final Set DANGEROUS_HTTP_METHODS = Set.of( + "POST", "PUT", "DELETE", "PATCH", "ANY" + ); @Override protected void registerFqnConsumer() { - checkFqns(List.of("aws_cdk.aws_apigateway.CfnMethod", "aws_cdk.aws_apigatewayv2.CfnRoute"), (subscriptionContext, callExpression) -> - getArgument(subscriptionContext, callExpression, AUTHORIZATION_TYPE).ifPresentOrElse( - argument -> argument.addIssueIf(isString("NONE"), MESSAGE), - () -> subscriptionContext.addIssue(callExpression.callee(), OMITTING_MESSAGE) - ) + // L1 constructs: flag only when authorization_type is explicitly the literal "NONE". + checkFqns(List.of("aws_cdk.aws_apigateway.CfnMethod", "aws_cdk.aws_apigatewayv2.CfnRoute"), + (ctx, call) -> getArgument(ctx, call, AUTHORIZATION_TYPE) + .ifPresent(arg -> arg.addIssueIf(isString("NONE"), MESSAGE)) ); - checkFqns(List.of("aws_cdk.aws_apigateway.RestApi", "aws_cdk.aws_apigateway.Resource.add_resource"), (subscriptionContext, callExpression) -> - getArgument(subscriptionContext, callExpression, "default_method_options").ifPresent( - argument -> { - if (isArgumentSafe(subscriptionContext, argument)) { - // if invocation of RestApi() or Resource.add_resource() is with the safe default, and it's in the method, - // then store the method's full qualified name in safeMethods - enclosingMethodFqn(callExpression).ifPresent(safeMethods::add); - } + // L2 construct: apply full detection pipeline. + checkFqn("aws_cdk.aws_apigateway.Resource.add_method", PublicApiIsSecuritySensitiveCheck::checkAddMethod); + } + + private static void checkAddMethod(SubscriptionContext ctx, CallExpression call) { + // Must be explicit literal NONE — omission is not flagged. + Optional authArg = getArgument(ctx, call, AUTHORIZATION_TYPE); + if (authArg.isEmpty() || !authArg.get().hasExpression(isFqn(AUTHORIZATION_TYPE_NONE))) { + return; + } + + // Path is normalised: lowercase and leading dots/slashes stripped so ".well-known" matches "well-known". + Optional path = resolveAddResourcePath(ctx, call).map(PublicApiIsSecuritySensitiveCheck::normalizePath); + if (path.isPresent() && SAFE_PATH_NAMES.contains(path.get())) { + return; + } + + // Suppress: parent RestApi has a PRIVATE endpoint — the API is VPC-only and unreachable from the internet. + if (isPrivateRestApi(ctx, call)) { + return; + } + + // Gate 1: state-changing HTTP method — sufficient to confirm a vulnerability. + Optional httpMethod = getArgument(ctx, call, HTTP_METHOD, 0); + if (httpMethod.isPresent() && httpMethod.get().hasExpression(isString(DANGEROUS_HTTP_METHODS))) { + authArg.get().addIssue(MESSAGE); + return; + } + + if (path.isPresent() && SENSITIVE_PATH_NAMES.contains(path.get())) { + authArg.get().addIssue(MESSAGE); + } + } + + private static boolean isPrivateRestApi(SubscriptionContext ctx, CallExpression addMethodCall) { + Expression callee = addMethodCall.callee(); + if (!callee.is(Tree.Kind.QUALIFIED_EXPR)) { + return false; + } + Expression qualifier = ((QualifiedExpression) callee).qualifier(); + CallExpression addResourceCall = resolveToAddResourceCall(qualifier); + if (addResourceCall != null) { + return walkChainToRestApi(addResourceCall) + .map(restApiCall -> hasPrivateEndpointConfiguration(ctx, restApiCall)) + .orElse(false); + } + // Fallback: add_method called directly on api.root (no add_resource in chain) + return resolveToRestApiFromRoot(qualifier) + .map(restApiCall -> hasPrivateEndpointConfiguration(ctx, restApiCall)) + .orElse(false); + } + + private static Optional walkChainToRestApi(CallExpression addResourceCall) { + Expression callee = addResourceCall.callee(); + if (!callee.is(Tree.Kind.QUALIFIED_EXPR)) { + return Optional.empty(); + } + Expression qualifier = ((QualifiedExpression) callee).qualifier(); + + // api.root.add_resource(...) — qualifier is a QualifiedExpression ending in .root + if (qualifier.is(Tree.Kind.QUALIFIED_EXPR)) { + QualifiedExpression qe = (QualifiedExpression) qualifier; + if ("root".equals(qe.name().name())) { + return resolveToRestApiCall(qe.qualifier()); + } + } + + // api.root.add_resource("a").add_resource("b") — qualifier is itself an add_resource call + if (qualifier.is(Tree.Kind.CALL_EXPR)) { + CallExpression inner = (CallExpression) qualifier; + if (isAddResourceCall(inner)) { + return walkChainToRestApi(inner); + } + } + + // resource = api.root.add_resource("a"); resource.add_resource("b") + if (qualifier.is(Tree.Kind.NAME)) { + Expression assigned = Expressions.singleAssignedValue((Name) qualifier); + if (assigned != null && assigned.is(Tree.Kind.CALL_EXPR)) { + CallExpression inner = (CallExpression) assigned; + if (isAddResourceCall(inner)) { + return walkChainToRestApi(inner); } - ) - ); + } + } - checkFqn("aws_cdk.aws_apigateway.Resource.add_method", (subscriptionContext, callExpression) -> - getArgument(subscriptionContext, callExpression, AUTHORIZATION_TYPE).ifPresentOrElse( - argument -> argument.addIssueIf(isFqn(AUTHORIZATION_TYPE_NONE), MESSAGE), - () -> enclosingMethodFqn(callExpression).filter(fqn -> !safeMethods.contains(fqn)).ifPresent(fnq -> - // if the invocation of Resource.add_method() is without explicit authorization_type argument, - // and it's not in the scope of safeMethod the call, then it's considered unsafe - // this is the best possible approximation for now - subscriptionContext.addIssue(callExpression.callee(), OMITTING_MESSAGE) - ) - ) - ); + return Optional.empty(); } - private static Optional enclosingMethodFqn(Tree tree) { - FunctionDef functionDef = (FunctionDef) TreeUtils.firstAncestorOfKind(tree, Tree.Kind.FUNCDEF); - return Optional.ofNullable(functionDef) - .map(FunctionDefImpl.class::cast) - .map(FunctionDefImpl::functionSymbol) - .map(Symbol::fullyQualifiedName); + private static Optional resolveToRestApiCall(Expression expression) { + Expression resolved = expression; + if (expression.is(Tree.Kind.NAME)) { + Expression assigned = Expressions.singleAssignedValue((Name) expression); + if (assigned != null) { + resolved = assigned; + } + } + if (resolved.is(Tree.Kind.CALL_EXPR)) { + CallExpression call = (CallExpression) resolved; + if (Optional.ofNullable(call.calleeSymbol()) + .map(Symbol::fullyQualifiedName) + .filter(REST_API_FQN::equals) + .isPresent()) { + return Optional.of(call); + } + } + return Optional.empty(); } - private static boolean isArgumentSafe(SubscriptionContext subscriptionContext, CdkUtils.ExpressionFlow argument) { - return !(isUnsafeSafeDictionaryAuthorisationKey(subscriptionContext, argument.getLast()) - || isUnsafeAuthorisationArgument(subscriptionContext, argument)); + private static Optional resolveToRestApiFromRoot(Expression expression) { + Expression resolved = expression; + if (expression.is(Tree.Kind.NAME)) { + Expression assigned = Expressions.singleAssignedValue((Name) expression); + if (assigned != null) { + resolved = assigned; + } + } + if (resolved.is(Tree.Kind.QUALIFIED_EXPR)) { + QualifiedExpression qe = (QualifiedExpression) resolved; + if ("root".equals(qe.name().name())) { + return resolveToRestApiCall(qe.qualifier()); + } + } + return Optional.empty(); } - private static boolean isUnsafeSafeDictionaryAuthorisationKey(SubscriptionContext ctx, Expression expression) { - return getDictionary(expression) - .flatMap(dictionary -> getDictionaryPair(ctx, dictionary, AUTHORIZATION_TYPE)) - .filter(element -> isFqn(AUTHORIZATION_TYPE_NONE).test(element.value.getLast())) - .isPresent(); + private static boolean hasPrivateEndpointConfiguration(SubscriptionContext ctx, CallExpression restApiCall) { + return getArgument(ctx, restApiCall, ENDPOINT_CONFIGURATION) + .flatMap(flow -> flow.getExpression(e -> e.is(Tree.Kind.CALL_EXPR) && isFqn(ENDPOINT_CONFIGURATION_FQN).test(e))) + .map(CallExpression.class::cast) + .flatMap(configCall -> getArgument(ctx, configCall, TYPES, 0)) + .flatMap(CdkUtils::getList) + .map(list -> CdkUtils.getListElements(ctx, list)) + .map(elements -> elements.stream().anyMatch(el -> el.hasExpression(isFqn(ENDPOINT_TYPE_PRIVATE_FQN)))) + .orElse(false); } - private static boolean isUnsafeAuthorisationArgument(SubscriptionContext subscriptionContext, CdkUtils.ExpressionFlow expression) { - return expression.getExpression(isCallExpression().and(isFqn("aws_cdk.aws_apigateway.MethodOptions"))) - .flatMap(expr -> getArgument(subscriptionContext, (CallExpression) expr, AUTHORIZATION_TYPE)) - .filter(expr -> expr.hasExpression(isFqn(AUTHORIZATION_TYPE_NONE))) - .isPresent(); + private static Optional resolveAddResourcePath(SubscriptionContext ctx, CallExpression addMethodCall) { + Expression callee = addMethodCall.callee(); + if (!callee.is(Tree.Kind.QUALIFIED_EXPR)) { + return Optional.empty(); + } + Expression qualifier = ((QualifiedExpression) callee).qualifier(); + CallExpression addResourceCall = resolveToAddResourceCall(qualifier); + if (addResourceCall == null) { + return Optional.empty(); + } + return getArgument(ctx, addResourceCall, PATH_PART, 0) + .flatMap(flow -> flow.getExpression(isStringLiteral())) + .flatMap(CdkUtils::getString); + } + + @CheckForNull + private static CallExpression resolveToAddResourceCall(Expression expression) { + if (expression.is(Tree.Kind.CALL_EXPR)) { + CallExpression call = (CallExpression) expression; + return isAddResourceCall(call) ? call : null; + } + if (expression.is(Tree.Kind.NAME)) { + Expression assigned = Expressions.singleAssignedValue((Name) expression); + if (assigned != null && assigned.is(Tree.Kind.CALL_EXPR)) { + CallExpression call = (CallExpression) assigned; + return isAddResourceCall(call) ? call : null; + } + } + return null; } - public static Predicate isCallExpression() { - return expression -> expression.is(Tree.Kind.CALL_EXPR); + private static String normalizePath(String path) { + return path.replaceAll("^[./]+", "").toLowerCase(Locale.ROOT); + } + + private static boolean isAddResourceCall(CallExpression call) { + return Optional.ofNullable(call.calleeSymbol()) + .map(Symbol::fullyQualifiedName) + .filter(ADD_RESOURCE_FQN::equals) + .isPresent(); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/PublicNetworkAccessToCloudResourcesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/PublicNetworkAccessToCloudResourcesCheck.java index b2040c941d..12f80b40ed 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/PublicNetworkAccessToCloudResourcesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/PublicNetworkAccessToCloudResourcesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/ResourceAccessPolicyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/ResourceAccessPolicyCheck.java index 5e1d257174..fdb8f42d73 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/ResourceAccessPolicyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/ResourceAccessPolicyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketBlockPublicAccessCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketBlockPublicAccessCheck.java index 52c1c4dc2b..2be26c9149 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketBlockPublicAccessCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketBlockPublicAccessCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -33,11 +33,11 @@ @Rule(key = "S6281") public class S3BucketBlockPublicAccessCheck extends AbstractS3BucketCheck { - private static final String MESSAGE = "Make sure allowing public ACL/policies to be set is safe here."; - private static final String OMITTING_MESSAGE = "No Public Access Block configuration prevents public ACL/policies to be set on this S3 bucket. Make sure it is safe here."; + private static final String MESSAGE = "Disabling public access block settings allows public ACL/policies to be set on this S3 bucket."; + private static final String BLOCK_ACLS_ONLY_MESSAGE = "Using BLOCK_ACLS_ONLY allows public access via bucket policies."; private static final String BLOCK_PUBLIC_ACCESS_FQN = "aws_cdk.aws_s3.BlockPublicAccess"; - private static final String BLOCK_ACLS_FQN = BLOCK_PUBLIC_ACCESS_FQN + ".BLOCK_ACLS"; + private static final String BLOCK_ACLS_ONLY_FQN = BLOCK_PUBLIC_ACCESS_FQN + ".BLOCK_ACLS_ONLY"; private static final List BLOCK_PUBLIC_ACCESS_ARGUMENTS = List.of( "block_public_acls", "ignore_public_acls", @@ -48,16 +48,12 @@ public class S3BucketBlockPublicAccessCheck extends AbstractS3BucketCheck { BiConsumer visitBucketConstructor() { return (ctx, bucket) -> { Optional blockPublicAccess = getArgument(ctx, bucket, "block_public_access"); - if (blockPublicAccess.isPresent()) { - checkBlockPublicAccess(ctx, blockPublicAccess.get()); - } else { - ctx.addIssue(bucket.callee(), OMITTING_MESSAGE); - } + blockPublicAccess.ifPresent(bpa -> checkBlockPublicAccess(ctx, bpa)); }; } private static void checkBlockPublicAccess(SubscriptionContext ctx, CdkUtils.ExpressionFlow blockPublicAccess) { - blockPublicAccess.addIssueIf(S3BucketBlockPublicAccessCheck::blocksAclsOnly, MESSAGE); + blockPublicAccess.addIssueIf(S3BucketBlockPublicAccessCheck::isBlockAclsOnly, BLOCK_ACLS_ONLY_MESSAGE); blockPublicAccess.locations().stream().filter(CallExpression.class::isInstance).map(CallExpression.class::cast) .filter(S3BucketBlockPublicAccessCheck::isBlockPublicAccessConstructor) .findAny() @@ -73,12 +69,12 @@ private static void visitBlockPublicAccessConstructor(SubscriptionContext ctx, C .forEach(flow -> flow.addIssueIf(isFalse(), MESSAGE)); } - private static boolean blocksAclsOnly(Expression expression) { + private static boolean isBlockAclsOnly(Expression expression) { if (expression.is(Tree.Kind.QUALIFIED_EXPR)) { QualifiedExpression qualifiedExpression = (QualifiedExpression) expression; return Optional.ofNullable(qualifiedExpression.symbol()) .map(Symbol::fullyQualifiedName) - .filter(BLOCK_ACLS_FQN::equals) + .filter(BLOCK_ACLS_ONLY_FQN::equals) .isPresent(); } return false; diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketGrantedAccessCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketGrantedAccessCheck.java index 8e3c6eedc9..96d2fb3628 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketGrantedAccessCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketGrantedAccessCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketHTTPCommunicationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketHTTPCommunicationCheck.java index a66b9e8431..2025361a94 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketHTTPCommunicationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketHTTPCommunicationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketServerEncryptionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketServerEncryptionCheck.java deleted file mode 100644 index ed91fe4be0..0000000000 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketServerEncryptionCheck.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.python.checks.cdk; - -import java.util.function.BiConsumer; -import org.sonar.check.Rule; -import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.tree.CallExpression; - -import static org.sonar.python.checks.cdk.CdkPredicate.isFqn; -import static org.sonar.python.checks.cdk.CdkUtils.getArgument; - -@Rule(key = "S6245") -public class S3BucketServerEncryptionCheck extends AbstractS3BucketCheck { - - private static final String S3_BUCKET_UNENCRYPTED_FQN = "aws_cdk.aws_s3.BucketEncryption.UNENCRYPTED"; - public static final String MESSAGE = "Objects in the bucket are not encrypted. Make sure it is safe here."; - public static final String OMITTING_MESSAGE = "Omitting 'encryption' disables server-side encryption. Make sure it is safe here."; - - @Override - BiConsumer visitBucketConstructor() { - return (ctx, bucket) -> getArgument(ctx, bucket, "encryption") - .ifPresentOrElse( - encryption -> encryption.addIssueIf(isFqn(S3_BUCKET_UNENCRYPTED_FQN), MESSAGE), - () -> checkEncryptionKey(ctx, bucket)); - } - - private static void checkEncryptionKey(SubscriptionContext ctx, CallExpression bucket) { - if (getArgument(ctx, bucket, "encryption_key").isEmpty()) { - ctx.addIssue(bucket.callee(), OMITTING_MESSAGE); - } - } -} diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketVersioningCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketVersioningCheck.java index 6cc3b8de2d..f014d00951 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketVersioningCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/S3BucketVersioningCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedEbsVolumeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedEbsVolumeCheck.java index 12a07a5d79..d1f2fb08ad 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedEbsVolumeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedEbsVolumeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedSageMakerNotebookCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedSageMakerNotebookCheck.java index 7d86b55819..46d9bdcd23 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedSageMakerNotebookCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedSageMakerNotebookCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedSqsQueueCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedSqsQueueCheck.java index 08a369b193..d2d5af5f3c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedSqsQueueCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnencryptedSqsQueueCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheck.java index 0de0b54ba9..3e812765c7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckPartCfnSecurity.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckPartCfnSecurity.java index 3ed6c2e140..1b03391cf3 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckPartCfnSecurity.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckPartCfnSecurity.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckPartConnections.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckPartConnections.java index 8e12a6d6de..350a78c165 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckPartConnections.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckPartConnections.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedOutboundCommunicationsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedOutboundCommunicationsCheck.java index d215677d29..9d6719490d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedOutboundCommunicationsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/UnrestrictedOutboundCommunicationsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/WeakSSLProtocolCheckPart.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/WeakSSLProtocolCheckPart.java index 0ad57bd015..1241cb237e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/WeakSSLProtocolCheckPart.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/WeakSSLProtocolCheckPart.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/cdk/package-info.java b/python-checks/src/main/java/org/sonar/python/checks/cdk/package-info.java index 44670788ee..c1a514955f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/cdk/package-info.java +++ b/python-checks/src/main/java/org/sonar/python/checks/cdk/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelFormFieldsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelFormFieldsCheck.java index 894716f05d..d288f38c3f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelFormFieldsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelFormFieldsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelStrMethodCheck.java b/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelStrMethodCheck.java index 99d0cd9daa..bb3e5aa463 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelStrMethodCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelStrMethodCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,14 +16,17 @@ */ package org.sonar.python.checks.django; -import java.util.List; import java.util.Objects; import java.util.Optional; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; @@ -34,14 +37,13 @@ public class DjangoModelStrMethodCheck extends PythonSubscriptionCheck { public static final String MESSAGE = "Define a \"__str__\" method for this Django model."; - private static final List DJANGO_MODEL_FQN = List.of("django.db.models.Model"); + private static final TypeMatcher IS_DJANGO_MODEL = TypeMatchers.isType("django.db.models.base.Model"); @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, ctx -> { var classDef = (ClassDef) ctx.syntaxNode(); - var parentClassesFQN = TreeUtils.getParentClassesFQN(classDef); - if (DJANGO_MODEL_FQN.equals(parentClassesFQN)) { + if (isDirectDjangoModelSubclass(classDef, ctx)) { if (isAbstractModel(classDef)) { return; } @@ -54,6 +56,18 @@ public void initialize(Context context) { }); } + private static boolean isDirectDjangoModelSubclass(ClassDef classDef, SubscriptionContext ctx) { + var args = classDef.args(); + if (args == null) { + return false; + } + return args.arguments().stream() + .filter(RegularArgument.class::isInstance) + .map(RegularArgument.class::cast) + .map(RegularArgument::expression) + .anyMatch(expr -> IS_DJANGO_MODEL.isTrueFor(expr, ctx)); + } + private static boolean isAbstractModel(ClassDef classDef) { return getMetaClass(classDef) .flatMap(metaClass -> getFieldAssignment(metaClass, "abstract")) diff --git a/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelStringFieldCheck.java b/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelStringFieldCheck.java index 3f90201cc7..6f8bb4af46 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelStringFieldCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/django/DjangoModelStringFieldCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -34,6 +34,8 @@ import org.sonar.plugins.python.api.tree.Statement; import org.sonar.plugins.python.api.tree.StatementList; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.quickfix.TextEditUtils; import org.sonar.python.tree.TreeUtils; @@ -45,7 +47,7 @@ public class DjangoModelStringFieldCheck extends PythonSubscriptionCheck { private static final String REPLACE_QUICK_FIX_MESSAGE = "Replace with \"blank=True\""; private static final String REMOVE_QUICK_FIX_MESSAGE = "Remove the \"null=true\" flag"; - private static final String DJANGO_MODEL_FQN = "django.db.models.Model"; + private static final TypeMatcher IS_DJANGO_MODEL = TypeMatchers.isOrExtendsType("django.db.models.base.Model"); public static final Set FIELD_TYPES_FQN = Set.of( "django.db.models.CharField", "django.db.models.TextField" @@ -55,7 +57,7 @@ public class DjangoModelStringFieldCheck extends PythonSubscriptionCheck { public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, ctx -> { var classDef = (ClassDef) ctx.syntaxNode(); - if (TreeUtils.getParentClassesFQN(classDef).contains(DJANGO_MODEL_FQN)) { + if (IS_DJANGO_MODEL.isTrueFor(classDef.name(), ctx)) { var modelClassBodyStatements = classDef.body().statements(); if (isNotManaged(modelClassBodyStatements)) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/django/DjangoUtils.java b/python-checks/src/main/java/org/sonar/python/checks/django/DjangoUtils.java index ca58a0aa70..6f7e21bd34 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/django/DjangoUtils.java +++ b/python-checks/src/main/java/org/sonar/python/checks/django/DjangoUtils.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -19,16 +19,32 @@ import java.util.Collection; import java.util.Objects; import java.util.Optional; +import java.util.regex.Pattern; +import org.sonar.plugins.python.api.PythonFile; import org.sonar.plugins.python.api.tree.AssignmentStatement; import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.FileInput; import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.python.tree.TreeUtils; public class DjangoUtils { + private static final Pattern GENERATED_MIGRATION_FILE_PATTERN = Pattern.compile("(^|.*/)migrations/0[^/]*\\.py$"); + private static final String MIGRATION_CLASS_NAME = "Migration"; + private static final String MIGRATIONS_MIGRATION = "migrations.Migration"; + private static final String DJANGO_DB_MIGRATIONS_MIGRATION = "django.db.migrations.Migration"; + private DjangoUtils() { } + public static boolean isDjangoGeneratedMigrationFile(PythonFile pythonFile, Tree tree) { + return isDjangoGeneratedMigrationPath(pythonFile) && findFileInput(tree).map(DjangoUtils::hasMigrationClass).orElse(false); + } + public static Optional getMetaClass(ClassDef formClass) { return formClass.body() .statements() @@ -54,4 +70,48 @@ public static Optional getFieldAssignment(ClassDef metaClas .anyMatch(name -> fieldName.equals(name.name()))) .findFirst(); } + + private static boolean isDjangoGeneratedMigrationPath(PythonFile pythonFile) { + String path = pythonFile.uri().getPath(); + if (path == null) { + return false; + } + return GENERATED_MIGRATION_FILE_PATTERN.matcher(path.replace('\\', '/')).matches(); + } + + private static Optional findFileInput(Tree tree) { + Tree current = tree; + while (current != null && !current.is(Tree.Kind.FILE_INPUT)) { + current = current.parent(); + } + return Optional.ofNullable(current).map(FileInput.class::cast); + } + + private static boolean hasMigrationClass(FileInput fileInput) { + if (fileInput.statements() == null) { + return false; + } + return fileInput.statements().statements().stream() + .filter(ClassDef.class::isInstance) + .map(ClassDef.class::cast) + .filter(classDef -> MIGRATION_CLASS_NAME.equals(classDef.name().name())) + .anyMatch(DjangoUtils::inheritsFromDjangoMigration); + } + + private static boolean inheritsFromDjangoMigration(ClassDef classDef) { + if (classDef.args() == null) { + return false; + } + return classDef.args().arguments().stream() + .filter(argument -> argument.is(Tree.Kind.REGULAR_ARGUMENT)) + .map(RegularArgument.class::cast) + .map(RegularArgument::expression) + .anyMatch(DjangoUtils::isDjangoMigrationBaseClass); + } + + private static boolean isDjangoMigrationBaseClass(Expression expression) { + return TreeUtils.fullyQualifiedNameFromExpression(expression) + .filter(fqn -> MIGRATIONS_MIGRATION.equals(fqn) || DJANGO_DB_MIGRATIONS_MIGRATION.equals(fqn)) + .isPresent(); + } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/django/package-info.java b/python-checks/src/main/java/org/sonar/python/checks/django/package-info.java index ff49152513..5bc4dffabc 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/django/package-info.java +++ b/python-checks/src/main/java/org/sonar/python/checks/django/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/AbstractCookieFlagCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/AbstractCookieFlagCheck.java index ae8167f0a2..20faca57eb 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/AbstractCookieFlagCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/AbstractCookieFlagCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/ClearTextProtocolsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/ClearTextProtocolsCheck.java index eb5cbaf488..8817b50a99 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/ClearTextProtocolsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/ClearTextProtocolsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,19 +16,15 @@ */ package org.sonar.python.checks.hotspots; -import java.net.URI; -import java.net.URISyntaxException; -import java.util.Arrays; import java.util.List; -import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.Set; -import java.util.regex.Pattern; import java.util.stream.Stream; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.TriBool; import org.sonar.plugins.python.api.symbols.Symbol; import org.sonar.plugins.python.api.tree.ArgList; import org.sonar.plugins.python.api.tree.Argument; @@ -42,22 +38,22 @@ import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.StringElement; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.checks.cdk.ClearTextProtocolsCheckPart; import org.sonar.python.tree.TreeUtils; +import org.sonarsource.analyzer.commons.appsec.CleartextProtocolFilter; @Rule(key = "S5332") public class ClearTextProtocolsCheck extends PythonSubscriptionCheck { - private static final List SENSITIVE_PROTOCOLS = Arrays.asList("http://", "ftp://", "telnet://"); - private static final Pattern LOOPBACK = Pattern.compile("localhost|127(?:\\.\\d+){0,2}\\.\\d+$|^(?:0*\\:)*?:?0*1", Pattern.CASE_INSENSITIVE); - private static final Map ALTERNATIVES = Map.of( - "http", "https", - "ftp", "sftp, scp or ftps", - "telnet", "ssh"); + private static final Set CLEARTEXT_PROTOCOLS = CleartextProtocolFilter.getCleartextProtocols(); private static final String SENSITIVE_HTTP_SERVER_START_FQN = "socketserver.BaseServer.serve_forever"; private static final String SENSITIVE_HTTP_SERVER_BIND_FQN = "socketserver.BaseServer.server_bind"; private static final Set SENSITIVE_HTTP_SERVER_METHOD_NAMES = Set.of("serve_forever", "server_bind"); private static final Set SENSITIVE_HTTP_SERVER_CLASSES = Set.of("http.server.HTTPServer", "http.server.ThreadingHTTPServer"); + private static final TypeMatcher STR_METHOD_MATCHER = TypeMatchers.isFunctionOwnerSatisfying(TypeMatchers.isOrExtendsType("builtins.str")); + private static final TypeMatcher STR_TYPE_MATCHER = TypeMatchers.isType("builtins.str"); @Override public void initialize(Context context) { @@ -65,6 +61,7 @@ public void initialize(Context context) { Tree node = ctx.syntaxNode(); String value = Expressions.unescape((StringElement) node); unsafeProtocol(value) + .filter(protocol -> !isStartsWithArgument(node, ctx)) // cleanup slashes .map(protocol -> protocol.substring(0, protocol.length() - 3)) .ifPresent(protocol -> ctx.addIssue(node, message(protocol))); @@ -166,28 +163,43 @@ private static void handleAssignmentStatement(AssignmentStatement assignmentStat } private static Optional unsafeProtocol(String literalValue) { - for (String protocol : SENSITIVE_PROTOCOLS) { - if (literalValue.startsWith(protocol)) { - try { - URI uri = new URI(literalValue); - String host = uri.getHost(); - if (host == null) { - // handle ipv6 loopback - host = uri.getAuthority(); - } - if (host == null || LOOPBACK.matcher(host).matches()) { - return Optional.empty(); - } - } catch (URISyntaxException e) { - // not parseable uri, try to find loopback in the substring without protocol, this handles case of url formatted as string - if (LOOPBACK.matcher(literalValue.substring(protocol.length())).find()) { - return Optional.empty(); - } + return CLEARTEXT_PROTOCOLS.stream() + .filter(literalValue::startsWith) + .filter(p -> { + String rest = literalValue.substring(p.length()); + if (rest.isEmpty()) { + // Bare scheme string (e.g. "http://") — always flag + return true; } - return Optional.of(protocol); - } + char first = rest.charAt(0); + if (first == '/' || first == '?' || first == '#') { + // No authority component (e.g. "http:///path") — no host to evaluate + return false; + } + return !CleartextProtocolFilter.isSafeWithoutTls(literalValue); + }) + .findFirst(); + } + + private static boolean isStartsWithArgument(Tree stringElement, SubscriptionContext context) { + Tree argumentParent = stringElement.parent().parent(); + while (argumentParent.is(Tree.Kind.TUPLE, Tree.Kind.PARENTHESIZED)) { + argumentParent = argumentParent.parent(); } - return Optional.empty(); + if (!(argumentParent instanceof RegularArgument argument) || argument.keywordArgument() != null) { + return false; + } + Tree callTree = TreeUtils.firstAncestorOfKind(argument, Tree.Kind.CALL_EXPR); + if (!(callTree instanceof CallExpression callExpression) + || !(callExpression.callee() instanceof QualifiedExpression callee) + || !"startswith".equals(callee.name().name()) + || STR_METHOD_MATCHER.evaluateFor(callee, context) == TriBool.FALSE) { + return false; + } + // unbound str.startswith(self, prefix) shifts the prefix to the second argument + int prefixIndex = STR_TYPE_MATCHER.evaluateFor(callee.qualifier(), context) == TriBool.TRUE ? 1 : 0; + List arguments = callExpression.arguments(); + return arguments.size() > prefixIndex && arguments.get(prefixIndex) == argument; } private static Optional isUnsafeLib(String qualifiedName) { @@ -204,6 +216,7 @@ private static Optional isUnsafeLib(String qualifiedName) { } private static String message(String protocol) { - return "Using " + protocol + " protocol is insecure. Use " + ALTERNATIVES.get(protocol) + " instead"; + return CleartextProtocolFilter.getIssueMessage(protocol) + .orElse("Using " + protocol + " protocol is insecure. Use a secure alternative instead."); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/CommandLineArgsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/CommandLineArgsCheck.java deleted file mode 100644 index 42c6f57fbe..0000000000 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/CommandLineArgsCheck.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.python.checks.hotspots; - -import java.util.Set; -import org.sonar.check.Rule; -import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.tree.Name; -import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.checks.AbstractCallExpressionCheck; -import org.sonar.plugins.python.api.symbols.Symbol; - -@Rule(key = CommandLineArgsCheck.CHECK_KEY) -public class CommandLineArgsCheck extends AbstractCallExpressionCheck { - public static final String CHECK_KEY = "S4823"; - private static final String MESSAGE = "Make sure that command line arguments are used safely here."; - private static final Set questionableFunctions = immutableSet("argparse.ArgumentParser", "optparse.OptionParser"); - - @Override - public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.NAME, CommandLineArgsCheck::checkSysArgNode); - super.initialize(context); - } - - private static void checkSysArgNode(SubscriptionContext ctx) { - Name nameTree = (Name) ctx.syntaxNode(); - Tree parent = nameTree.parent(); - Symbol symbol = nameTree.symbol(); - if (symbol != null && "sys.argv".equals(symbol.fullyQualifiedName())) { - if (isWithinImport(parent)) { - return; - } - ctx.addIssue(nameTree, MESSAGE); - } - } - - @Override - protected Set functionsToCheck() { - return questionableFunctions; - } - - @Override - protected String message() { - return MESSAGE; - } -} diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/CommonValidationUtils.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/CommonValidationUtils.java index 0f70a22066..7020508ad4 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/CommonValidationUtils.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/CommonValidationUtils.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -61,8 +61,12 @@ public static boolean isMoreThan(Expression expression, int number) { static boolean isLessThanExponent(Expression expression, int exponent) { if (expression.is(Tree.Kind.SHIFT_EXPR)) { var shiftExpression = (BinaryExpression) expression; - return shiftExpression.leftOperand().is(Tree.Kind.NUMERIC_LITERAL) && (((NumericLiteral) shiftExpression.leftOperand()).valueAsLong() == 1) - && isLessThan(shiftExpression.rightOperand(), exponent); + try { + return shiftExpression.leftOperand().is(Tree.Kind.NUMERIC_LITERAL) && (((NumericLiteral) shiftExpression.leftOperand()).valueAsLong() == 1) + && isLessThan(shiftExpression.rightOperand(), exponent); + } catch (NumberFormatException nfe) { + return false; + } } if (expression.is(Tree.Kind.NAME)) { return Expressions.singleAssignedNonNameValue(((Name) expression)) diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/CorsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/CorsCheck.java index 94321dbcdc..e4c304443d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/CorsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/CorsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/CsrfDisabledCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/CsrfDisabledCheck.java index 4619b9897f..46d5c688fc 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/CsrfDisabledCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/CsrfDisabledCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DataEncryptionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/DataEncryptionCheck.java deleted file mode 100644 index 0e162f3053..0000000000 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DataEncryptionCheck.java +++ /dev/null @@ -1,80 +0,0 @@ -/* - * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.python.checks.hotspots; - -import java.util.Arrays; -import java.util.List; -import org.sonar.check.Rule; -import org.sonar.plugins.python.api.PythonSubscriptionCheck; -import org.sonar.plugins.python.api.tree.CallExpression; -import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.plugins.python.api.symbols.Symbol; - -@Rule(key = "S4787") -public class DataEncryptionCheck extends PythonSubscriptionCheck { - - private static final List FUNCTIONS_TO_CHECK = Arrays.asList( - // pyca/cryptography: https://github.com/pyca/cryptography - "cryptography.fernet.Fernet", - "cryptography.hazmat.primitives.ciphers.aead.ChaCha20Poly1305", - "cryptography.hazmat.primitives.ciphers.aead.AESGCM", - "cryptography.hazmat.primitives.ciphers.aead.AESCCM", - "cryptography.hazmat.primitives.asymmetric.dh.generate_parameters", - "cryptography.hazmat.primitives.ciphers.Cipher", - // pyca/pynacl: https://github.com/pyca/pynacl - "nacl.public.Box", - "nacl.secret.SecretBox", - // PyCrypto: https://github.com/dlitz/pycrypto - "Crypto.Cipher.AES.new", - "Crypto.Cipher.DES.new", - "Crypto.Cipher.DES3.new", - "Crypto.Cipher.ARC2.new", - "Crypto.Cipher.ARC4.new", - "Crypto.Cipher.Blowfish.new", - "Crypto.Cipher.CAST.new", - "Crypto.Cipher.PKCS1_v1_5.new", - "Crypto.Cipher.PKCS1_OAEP.new", - "Crypto.Cipher.XOR.new", - "Crypto.Cipher.XOR.new", - "Crypto.PublicKey.ElGamal.generate", - // Cryptodome: https://github.com/Legrandin/pycryptodome - "Cryptodome.Cipher.AES.new", - "Cryptodome.Cipher.ChaCha20.new", - "Cryptodome.Cipher.DES.new", - "Cryptodome.Cipher.DES3.new", - "Cryptodome.Cipher.ARC2.new", - "Cryptodome.Cipher.ARC4.new", - "Cryptodome.Cipher.Blowfish.new", - "Cryptodome.Cipher.CAST.new", - "Cryptodome.Cipher.PKCS1_v1_5.new", - "Cryptodome.Cipher.PKCS1_OAEP.new", - "Cryptodome.Cipher.ChaCha20_Poly1305.new", - "Cryptodome.Cipher.Salsa20.new", - "Cryptodome.PublicKey.ElGamal.generate" - ); - - @Override - public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { - CallExpression callExpression = (CallExpression) ctx.syntaxNode(); - Symbol symbol = callExpression.calleeSymbol(); - if (symbol != null && FUNCTIONS_TO_CHECK.contains(symbol.fullyQualifiedName())) { - ctx.addIssue(callExpression, "Make sure that encrypting data is safe here."); - } - }); - } -} diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DebugModeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/DebugModeCheck.java index e8937fe236..2a8c34ff5b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DebugModeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/DebugModeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeCheck.java index ac95e70847..9cc3a83965 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeLegacyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeLegacyCheck.java index 6654b4e635..c35844af2d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeLegacyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeLegacyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DynamicCodeExecutionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/DynamicCodeExecutionCheck.java deleted file mode 100644 index 4630aa2dcf..0000000000 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/DynamicCodeExecutionCheck.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.python.checks.hotspots; - -import org.sonar.check.Rule; -import org.sonar.plugins.python.api.PythonSubscriptionCheck; -import org.sonar.plugins.python.api.tree.CallExpression; -import org.sonar.plugins.python.api.tree.Expression; -import org.sonar.plugins.python.api.tree.Name; -import org.sonar.plugins.python.api.tree.Tree; - -@Rule(key = "S1523") -public class DynamicCodeExecutionCheck extends PythonSubscriptionCheck { - private static final String MESSAGE = "Make sure that this dynamic injection or execution of code is safe."; - - @Override - public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { - CallExpression callExpr = (CallExpression) ctx.syntaxNode(); - if (isFuncNameExecOrEval(callExpr)) { - ctx.addIssue(callExpr, MESSAGE); - } - }); - } - - private static boolean isFuncNameExecOrEval(CallExpression call) { - Expression expr = call.callee(); - if (expr.is(Tree.Kind.NAME)) { - String functionName = ((Name) expr).name(); - return "exec".equals(functionName) || "eval".equals(functionName); - } - return false; - } -} diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/EmailSendingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/EmailSendingCheck.java deleted file mode 100644 index d887655699..0000000000 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/EmailSendingCheck.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.python.checks.hotspots; - -import java.util.Set; -import org.sonar.check.Rule; -import org.sonar.python.checks.AbstractCallExpressionCheck; - -@Rule(key = "S5300") -public class EmailSendingCheck extends AbstractCallExpressionCheck { - @Override - protected Set functionsToCheck() { - return immutableSet( - "django.core.mail.send_mail", - "django.core.mail.send_mass_mail", - "smtplib.SMTP.sendmail", - "smtplib.SMTP.send_message", - "smtplib.SMTP_SSL.sendmail", - "smtplib.SMTP_SSL.send_message", - "flask_mail.Mail.send", - "flask_mail.Mail.send_message", - "flask_mail.Connection.send", - "flask_mail.Connection.send_message" - ); - } - - @Override - protected String message() { - return "Make sure that this email is sent in a safe manner."; - } -} diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/ExpandingArchiveCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/ExpandingArchiveCheck.java index 168f80517e..5708344636 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/ExpandingArchiveCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/ExpandingArchiveCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/FastHashingOrPlainTextCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/FastHashingOrPlainTextCheck.java index 72e915e769..db86633c3f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/FastHashingOrPlainTextCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/FastHashingOrPlainTextCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -37,6 +37,8 @@ import org.sonar.plugins.python.api.tree.StringLiteral; import org.sonar.plugins.python.api.tree.SubscriptionExpression; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.checks.hotspots.CommonValidationUtils.ArgumentValidator; import org.sonar.python.checks.hotspots.CommonValidationUtils.CallValidator; import org.sonar.python.tree.TreeUtils; @@ -58,149 +60,144 @@ public class FastHashingOrPlainTextCheck extends PythonSubscriptionCheck { private static final String ARGON2_MESSAGE = "Use secure Argon2 parameters."; private static final String BCRYPT_MESSAGE = "Use strong bcrypt parameters."; private static final String DJANGO_MESSAGE = "Use a secure hashing algorithm to store passwords."; + private static final String DJANGO_PASSWORD_MESSAGE = "Use set_password() or create_user() to properly hash passwords."; private static final Set PBKDF2_ALGOS = Set.of( "sha1", "sha256", - "sha512" - ); + "sha512"); private static final String ROUNDS = "rounds"; private static final Set DJANGO_FIRST_FORBIDDEN_HASHERS = Set.of( "django.contrib.auth.hashers.SHA1PasswordHasher", "django.contrib.auth.hashers.MD5PasswordHasher", "django.contrib.auth.hashers.UnsaltedSHA1PasswordHasher", "django.contrib.auth.hashers.UnsaltedMD5PasswordHasher", - "django.contrib.auth.hashers.CryptPasswordHasher" - ); - + "django.contrib.auth.hashers.CryptPasswordHasher"); private static final ArgumentValidator SCRYPT_R = new ArgumentValidator( 3, "r", (ctx, argument) -> { - if (isLessThan(argument.expression(), 8)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 8)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator SCRYPT_BUFLEN = new ArgumentValidator( 5, "buflen", (ctx, argument) -> { - if (isLessThan(argument.expression(), 32)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 32)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator SCRYPT_N = new ArgumentValidator( 2, "N", (ctx, argument) -> { - if (isLessThan(argument.expression(), (int) Math.pow(2, 13)) || isLessThanExponent(argument.expression(), 13)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), (int) Math.pow(2, 13)) || isLessThanExponent(argument.expression(), 13)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator HASHLIB_R = new ArgumentValidator( 3, "r", (ctx, argument) -> { - if (isLessThan(argument.expression(), 8)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 8)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator HASHLIB_N = new ArgumentValidator( 2, "n", (ctx, argument) -> { - if (isLessThan(argument.expression(), (int) Math.pow(2, 13)) || isLessThanExponent(argument.expression(), 13)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), (int) Math.pow(2, 13)) || isLessThanExponent(argument.expression(), 13)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator HASHLIB_DKLEN = new ArgumentValidator( 6, "dklen", (ctx, argument) -> { - if (isLessThan(argument.expression(), 32)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 32)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator CRYPTOGRAPHY_R = new ArgumentValidator( 3, "r", (ctx, argument) -> { - if (isLessThan(argument.expression(), 8)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 8)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator CRYPTOGRAPHY_N = new ArgumentValidator( 2, "n", (ctx, argument) -> { - if (isLessThan(argument.expression(), (int) Math.pow(2, 13)) || isLessThanExponent(argument.expression(), 13)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), (int) Math.pow(2, 13)) || isLessThanExponent(argument.expression(), 13)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator CRYPTOGRAPHY_LENGTH = new ArgumentValidator( 1, "length", (ctx, argument) -> { - if (isLessThan(argument.expression(), 32)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 32)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator PASSLIB_BLOCK_SIZE = new ArgumentValidator( 3, "block_size", (ctx, argument) -> { - if (isLessThan(argument.expression(), 8)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 8)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator PASSLIB_ROUNDS = new ArgumentValidator( 2, ROUNDS, (ctx, argument) -> { - if (isLessThan(argument.expression(), 12)) { - ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); - } - }); - + if (isLessThan(argument.expression(), 12)) { + ctx.addIssue(argument, SCRYPT_PARAMETERS_MESSAGE); + } + }); private static final ArgumentValidator PASSLIB_PBKDF2 = new ArgumentValidator( 2, ROUNDS, (ctx, argument) -> { - if (isLessThan(argument.expression(), 100_000)) { - ctx.addIssue(argument, PBKDF2_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 100_000)) { + ctx.addIssue(argument, PBKDF2_MESSAGE); + } + }); private static final CallValidator CRYPTOGRAPHY_PBKDF2 = new PBKDF2Validator(0, "algorithm", 3, "iterations"); private static final CallValidator HASHLIB_PBKDF2 = new PBKDF2Validator(0, "hash_name", 3, "iterations"); private static final CallValidator PASSLIB_MISSING_ROUNDS = new MissingArgumentValidator( - 2, ROUNDS, PBKDF2_MESSAGE - ); + 2, ROUNDS, PBKDF2_MESSAGE); private static final CallValidator BCRYPT_GENSALT = new ArgumentValidator( 0, ROUNDS, (ctx, argument) -> { - if (isLessThan(argument.expression(), 12)) { - ctx.addIssue(argument, BCRYPT_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 12)) { + ctx.addIssue(argument, BCRYPT_MESSAGE); + } + }); private static final CallValidator BCRYPT_KDF = new ArgumentValidator( 3, ROUNDS, (ctx, argument) -> { - if (isLessThan(argument.expression(), 4096) || isLessThanExponent(argument.expression(), 12)) { - ctx.addIssue(argument, BCRYPT_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 4096) || isLessThanExponent(argument.expression(), 12)) { + ctx.addIssue(argument, BCRYPT_MESSAGE); + } + }); private static final CallValidator PASSLIB_BCRYPT = new ArgumentValidator( 3, ROUNDS, (ctx, argument) -> { - if (isLessThan(argument.expression(), 12)) { - ctx.addIssue(argument, BCRYPT_MESSAGE); - } - }); + if (isLessThan(argument.expression(), 12)) { + ctx.addIssue(argument, BCRYPT_MESSAGE); + } + }); private static final CallValidator FLASK_BCRYPT = new ArgumentValidator( 1, ROUNDS, (ctx, argument) -> { - if (isLessThan(argument.expression(), 12)) { - ctx.addIssue(argument, BCRYPT_MESSAGE); - } - }); - + if (isLessThan(argument.expression(), 12)) { + ctx.addIssue(argument, BCRYPT_MESSAGE); + } + }); private TypeCheckBuilder argon2IDTypeChecker = null; private final CallValidator argon2Type = new ArgumentValidator( 0, "type", (ctx, argument) -> { - if (argon2IDTypeChecker.check(argument.expression().typeV2()) == TriBool.FALSE) { - ctx.addIssue(argument, "Use Argon2ID to improve the security of the passwords."); - } - }); + if (argon2IDTypeChecker.check(argument.expression().typeV2()) == TriBool.FALSE) { + ctx.addIssue(argument, "Use Argon2ID to improve the security of the passwords."); + } + }); private TypeCheckBuilder argon2VersionTypeChecker = null; private final CallValidator argon2Version = new ArgumentValidator( 1, "version", (ctx, argument) -> { - var typeCheck = argon2VersionTypeChecker.check(argument.expression().typeV2()); - if (typeCheck == TriBool.TRUE) { - return; - } - if (!isEqualTo(argument.expression(), 19)) { - ctx.addIssue(argument, "Use the latest version of Argon2 ID."); - } - }); + var typeCheck = argon2VersionTypeChecker.check(argument.expression().typeV2()); + if (typeCheck == TriBool.TRUE) { + return; + } + if (!isEqualTo(argument.expression(), 19)) { + ctx.addIssue(argument, "Use the latest version of Argon2 ID."); + } + }); private final Map> callExpressionValidators = Map.ofEntries( Map.entry("scrypt.hash", List.of(SCRYPT_R, SCRYPT_BUFLEN, SCRYPT_N)), @@ -216,24 +213,24 @@ public class FastHashingOrPlainTextCheck extends PythonSubscriptionCheck { Map.entry("passlib.handlers.argon2._Argon2Common.using", List.of(new Argon2PasswordHasherValidator(3, 4, 5))), Map.entry("bcrypt.gensalt", List.of(BCRYPT_GENSALT)), Map.entry("bcrypt.kdf", List.of(BCRYPT_KDF)), - Map.entry("flask_bcrypt.generate_password_hash", List.of(FLASK_BCRYPT)) - ); + Map.entry("flask_bcrypt.generate_password_hash", List.of(FLASK_BCRYPT))); private static final Map> CALL_EXPRESSION_VALIDATORS_V1 = Map.ofEntries( - Map.entry("flask_bcrypt.Bcrypt.generate_password_hash", List.of(FLASK_BCRYPT)) - ); + Map.entry("flask_bcrypt.Bcrypt.generate_password_hash", List.of(FLASK_BCRYPT))); private static final Map> QUALIFIED_EXPR_VALIDATOR = Map.of( "passlib.hash.pbkdf2_sha1.using", List.of(PASSLIB_PBKDF2), "passlib.hash.pbkdf2_sha256.using", List.of(PASSLIB_PBKDF2, PASSLIB_MISSING_ROUNDS), "passlib.hash.pbkdf2_sha512.using", List.of(PASSLIB_PBKDF2, PASSLIB_MISSING_ROUNDS), - "passlib.hash.bcrypt.using", List.of(PASSLIB_BCRYPT) - ); + "passlib.hash.bcrypt.using", List.of(PASSLIB_BCRYPT)); + private static final TypeMatcher djangoUserInstanceMatcher = TypeMatchers.isObjectInstanceOf("django.contrib.auth.models.AbstractBaseUser"); + private static final TypeMatcher djangoUserManagerCreateTypeChecker = TypeMatchers.isType("django.contrib.auth.models.UserManager.create"); private TypeCheckBuilder argon2CheapestProfileTypeChecker = null; private TypeCheckBuilder flaskConfigTypeChecker = null; private TypeCheckMap> typeCheckMap = null; + @Override public void initialize(Context context) { context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, this::registerTypeCheckers); @@ -245,7 +242,8 @@ public void initialize(Context context) { }); context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, this::checkCallExpr); context.registerSyntaxNodeConsumer(Tree.Kind.NAME, this::checkName); - context.registerSyntaxNodeConsumer(Tree.Kind.ASSIGNMENT_STMT, subscriptionContext -> checkAssignment(subscriptionContext, flaskConfigTypeChecker)); + context.registerSyntaxNodeConsumer(Tree.Kind.ASSIGNMENT_STMT, subscriptionContext -> checkAssignmentOnFlaskConfig(subscriptionContext, flaskConfigTypeChecker)); + context.registerSyntaxNodeConsumer(Tree.Kind.ASSIGNMENT_STMT, FastHashingOrPlainTextCheck::checkDjangoUserPasswordAssignment); } private static void checkDjangoHasher(SubscriptionContext subscriptionContext) { @@ -275,6 +273,7 @@ private void registerTypeCheckers(SubscriptionContext subscriptionContext) { flaskConfigTypeChecker = subscriptionContext.typeChecker().typeCheckBuilder().isInstanceOf("flask.config.Config"); argon2IDTypeChecker = subscriptionContext.typeChecker().typeCheckBuilder().isTypeWithFqn("argon2.low_level.Type.ID"); argon2VersionTypeChecker = subscriptionContext.typeChecker().typeCheckBuilder().isTypeWithFqn("argon2.low_level.ARGON2_VERSION"); + typeCheckMap = new TypeCheckMap<>(); callExpressionValidators.forEach((key, value) -> { var typeCheckBuilder = subscriptionContext.typeChecker().typeCheckBuilder().isTypeWithFqn(key); @@ -282,7 +281,7 @@ private void registerTypeCheckers(SubscriptionContext subscriptionContext) { }); } - private static void checkAssignment(SubscriptionContext subscriptionContext, TypeCheckBuilder flaskConfigTypeChecker) { + private static void checkAssignmentOnFlaskConfig(SubscriptionContext subscriptionContext, TypeCheckBuilder flaskConfigTypeChecker) { var stmt = (AssignmentStatement) subscriptionContext.syntaxNode(); var lhsSubscription = stmt.lhsExpressions().stream().findFirst() .map(ExpressionList::expressions) @@ -313,6 +312,17 @@ private static boolean subscriptionIsFlaskBcryptConfig(Expression expression, Ty return subscriptMatch.isPresent(); } + private static void checkDjangoUserPasswordAssignment(SubscriptionContext subscriptionContext) { + var assignment = (AssignmentStatement) subscriptionContext.syntaxNode(); + // Check if LHS is `user.password = ...` where user is an instance of AbstractBaseUser + if (assignment.lhsExpressions().get(0).expressions().size() == 1 + && assignment.lhsExpressions().get(0).expressions().get(0) instanceof QualifiedExpression qualifiedExpression + && "password".equals(qualifiedExpression.name().name()) + && djangoUserInstanceMatcher.isTrueFor(qualifiedExpression.qualifier(), subscriptionContext)) { + subscriptionContext.addIssue(assignment.lhsExpressions().get(0), DJANGO_PASSWORD_MESSAGE); + } + } + private void checkName(SubscriptionContext subscriptionContext) { var name = (Name) subscriptionContext.syntaxNode(); if (argon2CheapestProfileTypeChecker.check(name.typeV2()) != TriBool.TRUE) { @@ -347,18 +357,27 @@ private void checkCallExpr(SubscriptionContext subscriptionContext) { var configs = QUALIFIED_EXPR_VALIDATOR.getOrDefault(fqn, List.of()); configs.forEach(config -> config.validate(subscriptionContext, callExpression)); } + + // Check for Django User.objects.create(password=...) - should use create_user() instead + checkDjangoUserManagerCreate(subscriptionContext, callExpression); + } + + private static void checkDjangoUserManagerCreate(SubscriptionContext subscriptionContext, CallExpression callExpression) { + if (!djangoUserManagerCreateTypeChecker.isTrueFor(callExpression.callee(), subscriptionContext)) { + return; + } + Optional.ofNullable(TreeUtils.argumentByKeyword("password", callExpression.arguments())) + .ifPresent(passwordArg -> subscriptionContext.addIssue(passwordArg, DJANGO_PASSWORD_MESSAGE)); } record PBKDF2Validator( int algoPosition, String algoKeyword, int iterationsPosition, - String iterationsKeyword - ) implements CallValidator { + String iterationsKeyword) implements CallValidator { @Override public void validate(SubscriptionContext ctx, CallExpression callExpression) { - var algoArgument = - nthArgumentOrKeywordOptional(algoPosition, algoKeyword, callExpression.arguments()); + var algoArgument = nthArgumentOrKeywordOptional(algoPosition, algoKeyword, callExpression.arguments()); var algoString = algoArgument .map(RegularArgument::expression) .map(CommonValidationUtils::singleAssignedString) @@ -382,17 +401,13 @@ public void validate(SubscriptionContext ctx, CallExpression callExpression) { record Argon2PasswordHasherValidator( int timeCostPosition, int memoryCostPosition, - int parallelismPosition - ) implements CallValidator { + int parallelismPosition) implements CallValidator { @Override public void validate(SubscriptionContext ctx, CallExpression callExpression) { - var timeCostArgument = - nthArgumentOrKeyword(timeCostPosition, "time_cost", callExpression.arguments()); - var memoryCostArgument = - nthArgumentOrKeyword(memoryCostPosition, "memory_cost", callExpression.arguments()); - var parallelismArgument = - nthArgumentOrKeyword(parallelismPosition, "parallelism", callExpression.arguments()); + var timeCostArgument = nthArgumentOrKeyword(timeCostPosition, "time_cost", callExpression.arguments()); + var memoryCostArgument = nthArgumentOrKeyword(memoryCostPosition, "memory_cost", callExpression.arguments()); + var parallelismArgument = nthArgumentOrKeyword(parallelismPosition, "parallelism", callExpression.arguments()); var isTimeCostNOk = timeCostArgument != null && isLessThan(timeCostArgument.expression(), 5); var isMemoryCostNOk = memoryCostArgument != null && isLessThan(memoryCostArgument.expression(), 7168); diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/GraphQLIntrospectionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/GraphQLIntrospectionCheck.java index 9ea18021d6..8b4615f079 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/GraphQLIntrospectionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/GraphQLIntrospectionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -71,8 +71,8 @@ private static boolean hasSafeMiddlewares(List arguments) { } Optional argumentValue = Expressions.ifNameGetSingleAssignedNonNameValue(argument.expression()); - boolean isNotTupleNorListLiteral = argumentValue.filter(a -> a.is(Tree.Kind.LIST_LITERAL, Tree.Kind.TUPLE)).isEmpty(); - return isNotTupleNorListLiteral || Expressions.expressionsFromListOrTuple(argumentValue.get()).stream().anyMatch(GraphQLIntrospectionCheck::isSafeMiddlewareName); + boolean isNotCollectionLiteral = argumentValue.filter(a -> a.is(Tree.Kind.LIST_LITERAL, Tree.Kind.TUPLE, Tree.Kind.SET_LITERAL)).isEmpty(); + return isNotCollectionLiteral || Expressions.expressionsFromListOrTuple(argumentValue.get()).stream().anyMatch(GraphQLIntrospectionCheck::isSafeMiddlewareName); } private static boolean hasSafeValidationRules(List arguments) { @@ -82,8 +82,8 @@ private static boolean hasSafeValidationRules(List arguments) { } Optional argumentValue = Expressions.ifNameGetSingleAssignedNonNameValue(argument.expression()); - boolean isNotTupleNorListLiteral = argumentValue.filter(a -> a.is(Tree.Kind.LIST_LITERAL, Tree.Kind.TUPLE)).isEmpty(); - return isNotTupleNorListLiteral || Expressions.expressionsFromListOrTuple(argumentValue.get()).stream().anyMatch(GraphQLIntrospectionCheck::isSafeValidationRule); + boolean isNotCollectionLiteral = argumentValue.filter(a -> a.is(Tree.Kind.LIST_LITERAL, Tree.Kind.TUPLE, Tree.Kind.SET_LITERAL)).isEmpty(); + return isNotCollectionLiteral || Expressions.expressionsFromListOrTuple(argumentValue.get()).stream().anyMatch(GraphQLIntrospectionCheck::isSafeValidationRule); } private static boolean isSafeValidationRule(Expression value) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/HardCodedCredentialsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/HardCodedCredentialsCheck.java index 01053f7ad0..83b91c1106 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/HardCodedCredentialsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/HardCodedCredentialsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -17,13 +17,13 @@ package org.sonar.python.checks.hotspots; import java.net.MalformedURLException; +import java.net.URI; +import java.net.URISyntaxException; import java.net.URL; import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; import java.util.List; -import java.util.Map; import java.util.Optional; +import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -55,45 +55,46 @@ import org.sonar.plugins.python.api.tree.SubscriptionExpression; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.tree.Tree.Kind; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.tree.TreeUtils; +import org.sonarsource.analyzer.commons.appsec.SecretClassifier; @Rule(key = "S2068") public class HardCodedCredentialsCheck extends PythonSubscriptionCheck { + public static final String MESSAGE = "\"%s\" detected here, review this potentially hard-coded credential."; private static final String DEFAULT_CREDENTIAL_WORDS = "password,passwd,pwd,passphrase"; private static final String FLASK_CONFIG_ASSIGNMENT_FQN = "flask.app.Flask.config"; private static final String FLASK_CONFIG_CREDENTIAL_KEY = "SECRET_KEY"; + private static final TypeMatcher GETENV_MATCHER = TypeMatchers.isType("os.getenv"); + private static final TypeMatcher ENVIRON_MATCHER = TypeMatchers.isType("os.environ"); + private static final TypeMatcher GET_ENVIRON_MATCHER = TypeMatchers.isType("typing.Mapping.get"); + + private static final TypeMatcher SENSITIVE_ARG_2_MATCHER = TypeMatchers.any( + TypeMatchers.isType("mysql.connector.connect"), + TypeMatchers.isType("mysql.connector.connection.MySQLConnection"), + TypeMatchers.isType("pymysql.connect"), + TypeMatchers.isType("pymysql.connections.connect"), + TypeMatchers.isType("pymysql.connections.Connection"), + TypeMatchers.isType("psycopg2.connect"), + // pgdb.connect is a module whose connect function has FQN pgdb.connect.connect. + // isType can't resolve it through the type table, so use withFQN to match on the FQN directly. + TypeMatchers.withFQN("pgdb.connect.connect")); + + private static final TypeMatcher SENSITIVE_ARG_5_MATCHER = TypeMatchers.any( + TypeMatchers.isType("pg.DB"), + TypeMatchers.isType("pg.connect")); + @RuleProperty( key = "credentialWords", description = "Comma separated list of words identifying potential credentials", defaultValue = DEFAULT_CREDENTIAL_WORDS) public String credentialWords = DEFAULT_CREDENTIAL_WORDS; - - public static final String MESSAGE = "\"%s\" detected here, review this potentially hard-coded credential."; - private List variablePatterns = null; private List literalPatterns = null; - private Map sensitiveArgumentByFQN; - - private Map sensitiveArgumentByFQN() { - if (sensitiveArgumentByFQN == null) { - sensitiveArgumentByFQN = new HashMap<>(); - sensitiveArgumentByFQN.put("mysql.connector.connect", 2); - sensitiveArgumentByFQN.put("mysql.connector.connection.MySQLConnection", 2); - sensitiveArgumentByFQN.put("pymysql.connect", 2); - sensitiveArgumentByFQN.put("pymysql.connections.connect", 2); - sensitiveArgumentByFQN.put("pymysql.connections.Connection", 2); - sensitiveArgumentByFQN.put("psycopg2.connect", 2); - sensitiveArgumentByFQN.put("pgdb.connect", 2); - sensitiveArgumentByFQN.put("pgdb.connect.connect", 2); - sensitiveArgumentByFQN.put("pg.DB", 5); - sensitiveArgumentByFQN.put("pg.connect", 5); - sensitiveArgumentByFQN = Collections.unmodifiableMap(sensitiveArgumentByFQN); - } - return sensitiveArgumentByFQN; - } private Stream variablePatterns() { if (variablePatterns == null) { @@ -132,14 +133,16 @@ private void handleDictionaryLiteral(DictionaryLiteral dictionaryLiteral, Subscr } private void checkKeyValuePair(KeyValuePair keyValuePair, SubscriptionContext ctx) { - if (keyValuePair.key().is(Kind.STRING_LITERAL) && keyValuePair.value().is(Kind.STRING_LITERAL)) { - String matchedCredential = matchedCredential(((StringLiteral) keyValuePair.key()).trimmedQuotesValue(), variablePatterns()); - if (matchedCredential != null) { - StringLiteral literal = (StringLiteral) keyValuePair.value(); - if (isSuspiciousStringLiteral(literal)) { - ctx.addIssue(keyValuePair, String.format(MESSAGE, matchedCredential)); - } - } + if (!keyValuePair.key().is(Kind.STRING_LITERAL)) { + return; + } + String matchedCredential = matchedCredential(((StringLiteral) keyValuePair.key()).trimmedQuotesValue(), variablePatterns()); + if (matchedCredential == null) { + return; + } + Expression value = keyValuePair.value(); + if (isSuspiciousStringLiteral(value) || isSuspiciousEnvGetDefault(value, ctx)) { + ctx.addIssue(keyValuePair, String.format(MESSAGE, matchedCredential)); } } @@ -167,13 +170,15 @@ private void handleRegularArgument(RegularArgument regularArgument, Subscription } } - private void handleCallExpression(CallExpression callExpression, SubscriptionContext ctx) { + private static void handleCallExpression(CallExpression callExpression, SubscriptionContext ctx) { if (callExpression.arguments().isEmpty()) { return; } - Symbol calleeSymbol = callExpression.calleeSymbol(); - if (calleeSymbol != null && sensitiveArgumentByFQN().containsKey(calleeSymbol.fullyQualifiedName())) { - checkSensitiveArgument(callExpression, sensitiveArgumentByFQN().get(calleeSymbol.fullyQualifiedName()), ctx); + Expression callee = callExpression.callee(); + if (SENSITIVE_ARG_2_MATCHER.isTrueFor(callee, ctx)) { + checkSensitiveArgument(callExpression, 2, ctx); + } else if (SENSITIVE_ARG_5_MATCHER.isTrueFor(callee, ctx)) { + checkSensitiveArgument(callExpression, 5, ctx); } } @@ -184,8 +189,11 @@ private static void checkSensitiveArgument(CallExpression callExpression, int ar RegularArgument regularArgument = (RegularArgument) argument; if (regularArgument.keywordArgument() != null) { return; - } else if (i == argNb && regularArgument.expression().is(Kind.STRING_LITERAL) && !((StringLiteral) regularArgument.expression()).trimmedQuotesValue().isEmpty()) { - ctx.addIssue(regularArgument, "Review this potentially hard-coded credential."); + } else if (i == argNb && regularArgument.expression().is(Kind.STRING_LITERAL)) { + String value = ((StringLiteral) regularArgument.expression()).trimmedQuotesValue(); + if (!value.isEmpty() && !SecretClassifier.isKnownNonSecret(value)) { + ctx.addIssue(regularArgument, "Review this potentially hard-coded credential."); + } } } } @@ -208,10 +216,10 @@ private void handleStringLiteral(StringLiteral stringLiteral, SubscriptionContex return; } - String matchedCredential = matchedCredential(literalValue, literalPatterns()); - if (matchedCredential != null) { - ctx.addIssue(stringLiteral, String.format(MESSAGE, matchedCredential)); - } + firstMatchingPattern(literalValue, literalPatterns()) + .filter(matcher -> !SecretClassifier.isKnownNonSecret(extractValueAfterEquals(matcher.group()))) + .ifPresent(matcher -> ctx.addIssue(stringLiteral, String.format(MESSAGE, credentialNameFromPattern(matcher.pattern())))); + if (isURLWithCredentials(stringLiteral)) { ctx.addIssue(stringLiteral, "Review this hard-coded URL, which may contain a credential."); } @@ -264,12 +272,13 @@ private static boolean isURLWithCredentials(StringLiteral stringLiteral) { return false; } try { - URL url = new URL(stringLiteral.trimmedQuotesValue()); + URL url = new URI(stringLiteral.trimmedQuotesValue()).toURL(); String userInfo = url.getUserInfo(); if (userInfo != null && userInfo.matches("\\S+:\\S+")) { - return true; + String password = userInfo.substring(userInfo.indexOf(':') + 1); + return !SecretClassifier.isKnownNonSecret(password); } - } catch (MalformedURLException e) { + } catch (URISyntaxException | MalformedURLException | IllegalArgumentException e) { return false; } return false; @@ -302,7 +311,7 @@ private void handleAssignmentStatement(AssignmentStatement assignmentStatement, private void checkAssignedValue(AssignmentStatement assignmentStatement, String matchedCredential, SubscriptionContext ctx) { Expression assignedValue = assignmentStatement.assignedValue(); - if (isSuspiciousStringLiteral(assignedValue) && !isFlaskConfigAssignment(assignedValue) ) { + if ((isSuspiciousStringLiteral(assignedValue) || isSuspiciousEnvGetDefault(assignedValue, ctx)) && !isFlaskConfigAssignment(assignedValue)) { ctx.addIssue(assignmentStatement, String.format(MESSAGE, matchedCredential)); } } @@ -315,26 +324,64 @@ private String credentialSymbolName(@CheckForNull Symbol symbol) { } private boolean isSuspiciousStringLiteral(Tree tree) { - return tree.is(Kind.STRING_LITERAL) && !((StringLiteral) tree).trimmedQuotesValue().isEmpty() - && !isCredential(((StringLiteral) tree).trimmedQuotesValue(), variablePatterns()); + if (!tree.is(Kind.STRING_LITERAL)) { + return false; + } + String value = ((StringLiteral) tree).trimmedQuotesValue(); + return !value.isEmpty() + && !isCredential(value, variablePatterns()) + && !SecretClassifier.isKnownNonSecret(value); + } + + private static boolean isSuspiciousEnvGetDefault(Expression expression, SubscriptionContext ctx) { + if (!expression.is(Kind.CALL_EXPR)) { + return false; + } + CallExpression call = (CallExpression) expression; + Expression callee = call.callee(); + if (!GETENV_MATCHER.isTrueFor(call.callee(), ctx) + && !(callee instanceof QualifiedExpression qExpr && GET_ENVIRON_MATCHER.isTrueFor(callee, ctx) && ENVIRON_MATCHER.isTrueFor(qExpr.qualifier(), ctx)) + ) { + return false; + } + return TreeUtils.nthArgumentOrKeywordOptional(1, "default", call.arguments()) + .map(RegularArgument::expression) + .filter(HardCodedCredentialsCheck::isNonEmptyStringLiteral) + .map(defaultExpr -> ((StringLiteral) defaultExpr).trimmedQuotesValue()) + .filter(value -> !SecretClassifier.isKnownNonSecret(value)) + .isPresent(); + } + + private static boolean isNonEmptyStringLiteral(Expression expression) { + return expression.is(Kind.STRING_LITERAL) && !((StringLiteral) expression).trimmedQuotesValue().isEmpty(); } private static boolean isCredential(String target, Stream patterns) { return patterns.anyMatch(pattern -> pattern.matcher(target).find()); } + private static Optional firstMatchingPattern(String target, Stream patterns) { + return patterns.map(pattern -> pattern.matcher(target)) + .filter(Matcher::find) + .findFirst(); + } + private static String matchedCredential(String target, Stream patterns) { - Optional matched = patterns.filter(pattern -> pattern.matcher(target).find()).findFirst(); - if (matched.isPresent()) { - String matchedPattern = matched.get().pattern(); - int suffixStart = matchedPattern.indexOf('='); - if (suffixStart > 0) { - return matchedPattern.substring(0, suffixStart); - } else { - return matchedPattern; - } - } - return null; + return firstMatchingPattern(target, patterns) + .map(matcher -> credentialNameFromPattern(matcher.pattern())) + .orElse(null); + } + + private static String credentialNameFromPattern(Pattern pattern) { + String regex = pattern.pattern(); + int suffixStart = regex.indexOf('='); + return suffixStart > 0 ? regex.substring(0, suffixStart) : regex; + } + + // literalPatterns() matches e.g. "password=hunter2" inside a literal; the value is whatever follows the first '='. + private static String extractValueAfterEquals(String match) { + int eq = match.indexOf('='); + return eq >= 0 ? match.substring(eq + 1) : match; } private List toPatterns(String suffix) { diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/HardCodedCredentialsEntropyCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/HardCodedCredentialsEntropyCheck.java index 80ad2331a4..adbfacfb73 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/HardCodedCredentialsEntropyCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/HardCodedCredentialsEntropyCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -36,6 +36,7 @@ import org.sonar.plugins.python.api.tree.Tree; import org.sonar.python.checks.utils.Expressions; import org.sonarsource.analyzer.commons.ShannonEntropy; +import org.sonarsource.analyzer.commons.appsec.SecretClassifier; @Rule(key = "S6418") public class HardCodedCredentialsEntropyCheck extends PythonSubscriptionCheck { @@ -76,7 +77,7 @@ private void patternMatch(Name name, Tree location, String value, SubscriptionCo } private void patternMatch(String name, Tree location, String value, SubscriptionContext subscriptionContext) { - if (!valuePassesPostValidation(value) || !entropyShouldRaise(value)) { + if (!valuePassesPostValidation(value) || !entropyShouldRaise(value) || SecretClassifier.isKnownNonSecret(value)) { return; } patterns().stream() diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/HashingDataCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/HashingDataCheck.java index 9a2e0df85b..e5950ebd8b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/HashingDataCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/HashingDataCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -34,10 +34,14 @@ import org.sonar.plugins.python.api.tree.HasSymbol; import org.sonar.plugins.python.api.tree.ListLiteral; import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.NumericLiteral; import org.sonar.plugins.python.api.tree.QualifiedExpression; import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.SliceExpression; +import org.sonar.plugins.python.api.tree.SliceItem; import org.sonar.plugins.python.api.tree.StringLiteral; import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.UnaryExpression; import org.sonar.python.checks.AbstractCallExpressionCheck; import org.sonar.python.checks.utils.Expressions; import org.sonar.python.tree.TreeUtils; @@ -100,6 +104,10 @@ public class HashingDataCheck extends AbstractCallExpressionCheck { private static final Set questionableHashers = immutableSet("crypt", "unsalted_sha1", "unsalted_md5", "sha1", "md5"); + // Maximum absolute value of a slice bound considered "small" (clearly not full-digest length). + // MD5 hex = 32 chars, MD5 bytes = 16 — anything ≤ 16 is unambiguously truncated. + private static final int BOUNDED_SLICE_MAX = 16; + @Override public void initialize(Context context) { super.initialize(context); @@ -221,11 +229,67 @@ private static void checkQuestionableHashingAlgorithm(SubscriptionContext ctx) { } String fullyQualifiedName = name.symbol() != null ? name.symbol().fullyQualifiedName() : ""; - if (questionableHashlibAlgorithm.contains(fullyQualifiedName) || questionablePasslibAlgorithm.contains(fullyQualifiedName)) { + if (questionableHashlibAlgorithm.contains(fullyQualifiedName)) { + if (!isHashlibCallConsumedByBoundedSlice(name)) { + ctx.addIssue(name, MESSAGE); + } + } else if (questionablePasslibAlgorithm.contains(fullyQualifiedName)) { ctx.addIssue(name, MESSAGE); } } + private static boolean isHashlibCallConsumedByBoundedSlice(Name name) { + Tree callTree = TreeUtils.firstAncestorOfKind(name, Tree.Kind.CALL_EXPR); + if (!(callTree instanceof CallExpression hashlibCall)) { + return false; + } + + // The call may optionally be chained with .hexdigest() or .digest() before being sliced. + Tree candidate = hashlibCall; + Tree parent = hashlibCall.parent(); + + if (parent instanceof QualifiedExpression qualExpr) { + String member = qualExpr.name().name(); + if (("hexdigest".equals(member) || "digest".equals(member)) && qualExpr.parent() instanceof CallExpression digestCall) { + candidate = digestCall; + parent = digestCall.parent(); + } + } + + return parent instanceof SliceExpression sliceExpr + && sliceExpr.object() == candidate + && isBoundedSlice(sliceExpr); + } + + private static boolean isBoundedSlice(SliceExpression sliceExpr) { + List slices = sliceExpr.sliceList().slices(); + if (slices.size() != 1) { + return false; + } + // A single-item SliceExpression always holds a SliceItem (parser invariant). + SliceItem sliceItem = (SliceItem) slices.get(0); + // [:N] or [M:N] — small positive upper bound + if (sliceItem.upperBound() instanceof NumericLiteral numLit) { + return isBoundedLiteral(numLit); + } + // [-N:] — negative lower bound, no upper bound (last N elements) + boolean isUnboundedAbove = sliceItem.upperBound() == null && sliceItem.stride() == null; + return isUnboundedAbove + && sliceItem.lowerBound() instanceof UnaryExpression unary + && unary.is(Tree.Kind.UNARY_MINUS) + && unary.expression() instanceof NumericLiteral numLit + && isBoundedLiteral(numLit); + } + + private static boolean isBoundedLiteral(NumericLiteral lit) { + try { + long v = lit.valueAsLong(); + return v > 0 && v <= BOUNDED_SLICE_MAX; + } catch (NumberFormatException e) { + return false; + } + } + private static String getQualifiedName(Expression node) { if (node instanceof HasSymbol hasSymbol) { Symbol symbol = hasSymbol.symbol(); diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/HttpOnlyCookieCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/HttpOnlyCookieCheck.java index 48261ebf7a..2a9ad42b6d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/HttpOnlyCookieCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/HttpOnlyCookieCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/LoggersConfigurationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/LoggersConfigurationCheck.java deleted file mode 100644 index b60499c00a..0000000000 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/LoggersConfigurationCheck.java +++ /dev/null @@ -1,91 +0,0 @@ -/* - * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.python.checks.hotspots; - -import java.util.Arrays; -import java.util.List; -import org.sonar.check.Rule; -import org.sonar.plugins.python.api.PythonSubscriptionCheck; -import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.tree.ArgList; -import org.sonar.plugins.python.api.tree.AssignmentStatement; -import org.sonar.plugins.python.api.tree.CallExpression; -import org.sonar.plugins.python.api.tree.ClassDef; -import org.sonar.plugins.python.api.tree.HasSymbol; -import org.sonar.plugins.python.api.tree.RegularArgument; -import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.plugins.python.api.symbols.Symbol; - -@Rule(key = "S4792") -public class LoggersConfigurationCheck extends PythonSubscriptionCheck { - - private static final List FUNCTIONS_TO_CHECK = Arrays.asList( - "logging.basicConfig", - "logging.disable", - "logging.setLoggerClass", - "logging.config.fileConfig", - "logging.config.dictConfig"); - - private static final List LOGGERS_CLASSES = Arrays.asList( - "logging.Logger", - "logging.Handler", - "logging.Filter"); - - private static final String MESSAGE = "Make sure that this logger's configuration is safe."; - - @Override - public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { - CallExpression callExpressionTree = (CallExpression) ctx.syntaxNode(); - Symbol symbol = callExpressionTree.calleeSymbol(); - if (symbol != null && FUNCTIONS_TO_CHECK.contains(symbol.fullyQualifiedName())) { - ctx.addIssue(callExpressionTree, MESSAGE); - } - }); - - context.registerSyntaxNodeConsumer(Tree.Kind.ASSIGNMENT_STMT, ctx -> isSettingLastResort(ctx, (AssignmentStatement) ctx.syntaxNode())); - - context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, ctx -> isClassExtendingLogger(ctx, (ClassDef) ctx.syntaxNode())); - } - - private static void isClassExtendingLogger(SubscriptionContext ctx, ClassDef classDef) { - ArgList argList = classDef.args(); - if (argList != null) { - argList.arguments().stream() - .filter(argument -> argument.is(Tree.Kind.REGULAR_ARGUMENT)) - .map(RegularArgument.class::cast) - .map(RegularArgument::expression) - .filter(expr -> expr instanceof HasSymbol hasSymbol && hasSymbol.symbol() != null) - .filter(expr -> LOGGERS_CLASSES.contains(((HasSymbol) expr).symbol().fullyQualifiedName())) - .forEach(expr -> ctx.addIssue(expr, MESSAGE)); - } - } - - // check if logging.lastResort is being set - private static void isSettingLastResort(SubscriptionContext ctx, AssignmentStatement assignment) { - assignment.lhsExpressions().stream() - .flatMap(exprList -> exprList.expressions().stream()) - .forEach(expr -> { - if (expr instanceof HasSymbol hasSymbol) { - Symbol symbol = hasSymbol.symbol(); - if (symbol != null && "logging.lastResort".equals(symbol.fullyQualifiedName())) { - ctx.addIssue(expr, MESSAGE); - } - } - }); - } -} diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/NonStandardCryptographicAlgorithmCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/NonStandardCryptographicAlgorithmCheck.java index 6158c69aab..3c3106d421 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/NonStandardCryptographicAlgorithmCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/NonStandardCryptographicAlgorithmCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/OsExecCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/OsExecCheck.java deleted file mode 100644 index 47fd373af2..0000000000 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/OsExecCheck.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.python.checks.hotspots; - -import java.util.Arrays; -import java.util.HashSet; -import java.util.Set; -import org.sonar.check.Rule; -import org.sonar.python.checks.AbstractCallExpressionCheck; - -@Rule(key = OsExecCheck.CHECK_KEY) -public class OsExecCheck extends AbstractCallExpressionCheck { - - public static final String CHECK_KEY = "S4721"; - private static final String MESSAGE = "Make sure that executing this OS command is safe here."; - - private static final Set questionableFunctions = new HashSet<>(Arrays.asList("subprocess.run", - "subprocess.Popen", - "subprocess.call", - "subprocess.check_call", - "subprocess.check_output", - "subprocess.getstatusoutput", - "subprocess.getoutput", - "os.system", - "os.spawnl", - "os.spawnle", - "os.spawnlp", - "os.spawnlpe", - "os.spawnv", - "os.spawnve", - "os.spawnvp", - "os.spawnvpe", - "os.popen", - "os.startfile", - "os.execl", - "os.execle", - "os.execlp", - "os.execlpe", - "os.execv", - "os.execve", - "os.execvp", - "os.execvpe", - "os.popen2", - "os.popen3", - "os.popen4", - "popen2.popen2", - "popen2.popen3", - "popen2.popen4" - )); - - @Override - protected Set functionsToCheck() { - return questionableFunctions; - } - - @Override - protected String message() { - return MESSAGE; - } -} diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/ProcessSignallingCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/ProcessSignallingCheck.java index 2862d1e73e..76f5d54588 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/ProcessSignallingCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/ProcessSignallingCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/PseudoRandomCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/PseudoRandomCheck.java index 4c5fcfe87c..9f30986b0b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/PseudoRandomCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/PseudoRandomCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/PubliclyWritableDirectoriesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/PubliclyWritableDirectoriesCheck.java index 369c043bad..2b31f86823 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/PubliclyWritableDirectoriesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/PubliclyWritableDirectoriesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/RegexCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/RegexCheck.java deleted file mode 100644 index b775ddd134..0000000000 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/RegexCheck.java +++ /dev/null @@ -1,113 +0,0 @@ -/* - * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.python.checks.hotspots; - -import java.util.Arrays; -import java.util.HashSet; -import java.util.Set; -import javax.annotation.Nullable; -import org.sonar.check.Rule; -import org.sonar.plugins.python.api.PythonSubscriptionCheck; -import org.sonar.plugins.python.api.SubscriptionContext; -import org.sonar.plugins.python.api.tree.Argument; -import org.sonar.plugins.python.api.tree.AssignmentExpression; -import org.sonar.plugins.python.api.tree.BinaryExpression; -import org.sonar.plugins.python.api.tree.CallExpression; -import org.sonar.plugins.python.api.tree.Expression; -import org.sonar.plugins.python.api.tree.Name; -import org.sonar.plugins.python.api.tree.RegularArgument; -import org.sonar.plugins.python.api.tree.StringLiteral; -import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.plugins.python.api.IssueLocation; -import org.sonar.python.checks.utils.Expressions; -import org.sonar.plugins.python.api.symbols.Symbol; - -@Rule(key = RegexCheck.CHECK_KEY) -public class RegexCheck extends PythonSubscriptionCheck { - public static final String CHECK_KEY = "S4784"; - private static final String MESSAGE = "Make sure that using a regular expression is safe here."; - private static final int REGEX_ARGUMENT = 0; - private static final Set questionableFunctions = new HashSet<>(Arrays.asList( - "django.core.validators.RegexValidator", "django.urls.conf.re_path", - "re.compile", "re.match", "re.search", "re.fullmatch", "re.split", "re.findall", "re.finditer", "re.sub", "re.subn", - "regex.compile", "regex.match", "regex.search", "regex.fullmatch", "regex.split", "regex.findall", "regex.finditer", "regex.sub", "regex.subn", - "regex.subf", "regex.subfn", "regex.splititer")); - - @Override - public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { - CallExpression call = (CallExpression) ctx.syntaxNode(); - Symbol symbol = call.calleeSymbol(); - if (symbol != null && questionableFunctions.contains(symbol.fullyQualifiedName()) && !call.arguments().isEmpty()) { - checkRegexArgument(call.arguments().get(REGEX_ARGUMENT), ctx); - } - }); - } - - private static void checkRegexArgument(Argument arg, SubscriptionContext ctx) { - String literal = null; - IssueLocation secondaryLocation = null; - if (!arg.is(Tree.Kind.REGULAR_ARGUMENT)) { - return; - } - Expression argExpression = getExpression(((RegularArgument) arg).expression()); - if (argExpression.is(Tree.Kind.NAME)) { - Expression expression = getExpression(Expressions.singleAssignedValue((Name) argExpression)); - if (expression != null && expression.is(Tree.Kind.STRING_LITERAL)) { - secondaryLocation = IssueLocation.preciseLocation(expression, ""); - literal = Expressions.unescape((StringLiteral) expression); - } - } else if (argExpression.is(Tree.Kind.STRING_LITERAL)) { - literal = Expressions.unescape((StringLiteral) argExpression); - } - if (literal == null) { - return; - } - if (isSuspiciousRegex(literal)) { - PreciseIssue preciseIssue = ctx.addIssue(arg, MESSAGE); - if (secondaryLocation != null) { - preciseIssue.secondary(secondaryLocation); - } - } - } - - private static Expression getExpression(@Nullable Expression expr) { - if (expr == null) { - return null; - } - expr = Expressions.removeParentheses(expr); - if (expr.is(Tree.Kind.MODULO) || expr.is(Tree.Kind.PLUS)) { - return getExpression(((BinaryExpression) expr).leftOperand()); - } - if (expr.is(Tree.Kind.ASSIGNMENT_EXPRESSION)) { - return getExpression(((AssignmentExpression) expr).expression()); - } - return expr; - } - - /** - * This rule flags any execution of a hardcoded regular expression which has at least 3 characters and at least - * two instances of any of the following characters: "*+{" (Example: (a+)*) - */ - private static boolean isSuspiciousRegex(String regexp) { - if (regexp.length() > 2) { - int nOfSuspiciousChars = regexp.length() - regexp.replaceAll("[*+{]", "").length(); - return nOfSuspiciousChars > 1; - } - return false; - } -} diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/SQLQueriesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/SQLQueriesCheck.java index f7bea76f39..379bd1852e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/SQLQueriesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/SQLQueriesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -111,8 +111,8 @@ private void checkCallExpression(SubscriptionContext context) { } private static void addIssue(SubscriptionContext context, CallExpression callExpression) { - Optional secondary = sensitiveArgumentValue(callExpression); - secondary.ifPresent(tree -> context.addIssue(callExpression, MESSAGE).secondary(tree, null)); + Optional secondary = sensitiveArgumentValue(callExpression, context); + secondary.ifPresent(tree -> context.addIssue(callExpression, MESSAGE).secondary(tree, null)); } private static boolean isException(CallExpression callExpression, String functionName) { @@ -123,7 +123,7 @@ private static boolean isException(CallExpression callExpression, String functio return argListNode.isEmpty(); } - private static Optional sensitiveArgumentValue(CallExpression callExpression) { + private static Optional sensitiveArgumentValue(CallExpression callExpression, SubscriptionContext ctx) { List argListNode = callExpression.arguments(); if (argListNode.isEmpty()) { return Optional.empty(); @@ -134,14 +134,27 @@ private static Optional sensitiveArgumentValue(CallExpression callExpressi } Expression expression = getExpression(((RegularArgument) arg).expression()); if (expression.is(Tree.Kind.NAME)) { - expression = Expressions.singleAssignedValue((Name) expression); + return findFormattedValue((Name) expression, ctx); } - if (expression != null && isFormatted(expression)) { + if (isFormatted(expression)) { return Optional.of(expression); } return Optional.empty(); } + private static Optional findFormattedValue(Name name, SubscriptionContext ctx) { + Set values = ctx.valuesAtLocation(name); + if (!values.isEmpty()) { + return values.stream() + .filter(SQLQueriesCheck::isFormatted) + .findFirst() + .map(Tree.class::cast); + } + return Optional.ofNullable(Expressions.singleAssignedValue(name)) + .filter(SQLQueriesCheck::isFormatted) + .map(Tree.class::cast); + } + private static boolean isFormatted(Expression tree) { FormattedStringVisitor visitor = new FormattedStringVisitor(); tree.accept(visitor); diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/SecureCookieCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/SecureCookieCheck.java index 7b09330627..f8de4e8fc3 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/SecureCookieCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/SecureCookieCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/StandardInputCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/StandardInputCheck.java deleted file mode 100644 index c5544d797b..0000000000 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/StandardInputCheck.java +++ /dev/null @@ -1,100 +0,0 @@ -/* - * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl - * mailto:info AT sonarsource DOT com - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the Sonar Source-Available License for more details. - * - * You should have received a copy of the Sonar Source-Available License - * along with this program; if not, see https://sonarsource.com/license/ssal/ - */ -package org.sonar.python.checks.hotspots; - -import java.util.Set; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.sonar.check.Rule; -import org.sonar.plugins.python.api.tree.CallExpression; -import org.sonar.plugins.python.api.tree.Expression; -import org.sonar.plugins.python.api.tree.Name; -import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.checks.AbstractCallExpressionCheck; -import org.sonar.plugins.python.api.symbols.Symbol; - -@Rule(key = StandardInputCheck.CHECK_KEY) -public class StandardInputCheck extends AbstractCallExpressionCheck { - public static final String CHECK_KEY = "S4829"; - private static final String MESSAGE = "Make sure that reading the standard input is safe here."; - private static final Set fileInputFunctions = immutableSet("fileinput.input", "fileinput.FileInput"); - private static final Set sysFunctions = immutableSet("sys.stdin.read", "sys.stdin.readline", "sys.stdin.readlines", - "sys.__stdin__.read", "sys.__stdin__.readline", "sys.__stdin__.readlines"); - private static final Set questionableFunctionsBuiltIn = immutableSet( - "raw_input", "input"); - private static final Set questionablePropertyAccess = immutableSet("sys.stdin", "sys.__stdin__"); - - @Override - public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { - CallExpression callExpr = (CallExpression) ctx.syntaxNode(); - if (questionableFunctionsBuiltIn.contains(getFunctionName(callExpr.callee()))) { - ctx.addIssue(callExpr, message()); - } else { - visitNode(ctx); - } - }); - context.registerSyntaxNodeConsumer(Tree.Kind.NAME, ctx -> { - Name name = (Name) ctx.syntaxNode(); - if (isWithinImport(name)) { - return; - } - if (isQuestionablePropertyAccess(name)) { - ctx.addIssue(name, message()); - } - }); - } - - private static String getFunctionName(Expression expr) { - String functionName = ""; - if (expr.is(Tree.Kind.NAME)) { - functionName = ((Name) expr).name(); - } - return functionName; - } - - @Override - protected boolean isException(CallExpression callExpression) { - Symbol symbol = callExpression.calleeSymbol(); - return symbol != null && fileInputFunctions.contains(symbol.fullyQualifiedName()) && !callExpression.arguments().isEmpty(); - } - - private static boolean isQuestionablePropertyAccess(Name pyNameTree) { - Tree parent = pyNameTree.parent(); - while (parent != null && !parent.is(Tree.Kind.CALL_EXPR)) { - Tree grandParent = parent.parent(); - if (grandParent != null && grandParent.is(Tree.Kind.CALL_EXPR) && ((CallExpression) grandParent).callee() == parent) { - // avoid raising twice the issue on call expressions like sys.stdin.read() - return false; - } - parent = grandParent; - } - Symbol symbol = pyNameTree.symbol(); - return symbol != null && questionablePropertyAccess.contains(symbol.fullyQualifiedName()); - } - - @Override - protected Set functionsToCheck() { - return Stream.concat(fileInputFunctions.stream(), sysFunctions.stream()) - .collect(Collectors.toSet()); - } - - @Override - protected String message() { - return MESSAGE; - } -} diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/StrongCryptographicKeysCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/StrongCryptographicKeysCheck.java index 106ab0c48c..f0a11045c8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/StrongCryptographicKeysCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/StrongCryptographicKeysCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/UnsafeHttpMethodsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/UnsafeHttpMethodsCheck.java index 89b58dabde..630d20fd08 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/UnsafeHttpMethodsCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/UnsafeHttpMethodsCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,146 +16,116 @@ */ package org.sonar.python.checks.hotspots; -import java.util.Arrays; -import java.util.HashSet; -import java.util.List; -import java.util.Objects; import java.util.Optional; -import java.util.Set; import org.sonar.check.Rule; import org.sonar.plugins.python.api.PythonSubscriptionCheck; import org.sonar.plugins.python.api.SubscriptionContext; import org.sonar.plugins.python.api.symbols.FunctionSymbol; -import org.sonar.plugins.python.api.symbols.Symbol; -import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.BinaryExpression; import org.sonar.plugins.python.api.tree.CallExpression; import org.sonar.plugins.python.api.tree.Decorator; import org.sonar.plugins.python.api.tree.Expression; -import org.sonar.plugins.python.api.tree.FileInput; import org.sonar.plugins.python.api.tree.FunctionDef; -import org.sonar.plugins.python.api.tree.ListLiteral; -import org.sonar.plugins.python.api.tree.RegularArgument; -import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.IfStatement; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.ParenthesizedExpression; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.UnknownType; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; import org.sonar.python.semantic.FunctionSymbolImpl; import org.sonar.python.tree.FunctionDefImpl; -import org.sonar.python.tree.TreeUtils; - -import static org.sonar.plugins.python.api.tree.Tree.Kind.CALL_EXPR; -import static org.sonar.plugins.python.api.tree.Tree.Kind.FILE_INPUT; -import static org.sonar.plugins.python.api.tree.Tree.Kind.FUNCDEF; -import static org.sonar.plugins.python.api.tree.Tree.Kind.LIST_LITERAL; -import static org.sonar.plugins.python.api.tree.Tree.Kind.REGULAR_ARGUMENT; -import static org.sonar.plugins.python.api.tree.Tree.Kind.STRING_LITERAL; -import static org.sonar.python.tree.TreeUtils.argumentByKeyword; -import static org.sonar.python.tree.TreeUtils.getSymbolFromTree; @Rule(key = "S3752") public class UnsafeHttpMethodsCheck extends PythonSubscriptionCheck { - private static final Set SAFE_HTTP_METHODS = new HashSet<>(Arrays.asList("GET", "HEAD", "OPTIONS")); - private static final Set UNSAFE_HTTP_METHODS = new HashSet<>(Arrays.asList("POST", "PUT", "DELETE")); - private static final Set COMPLIANT_DECORATORS = new HashSet<>(Arrays.asList( - "django.views.decorators.http.require_POST", - "django.views.decorators.http.require_GET", - "django.views.decorators.http.require_safe" - )); - private static final String MESSAGE = "Make sure allowing safe and unsafe HTTP methods is safe here."; + private static final TypeMatcher COMPLIANT_DECORATORS = TypeMatchers.any( + TypeMatchers.isType("django.views.decorators.http.require_POST"), + TypeMatchers.isType("django.views.decorators.http.require_GET"), + TypeMatchers.isType("django.views.decorators.http.require_safe")); + + private static final TypeMatcher IS_REQUIRED_HTTP_METHOD = TypeMatchers.isType("django.views.decorators.http.require_http_methods"); + + private static final String MESSAGE = "Explicitly specify the HTTP methods this endpoint accepts."; @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(FUNCDEF, ctx -> { + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, ctx -> { FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); if (isDjangoView(functionDef)) { checkDjangoView(functionDef, ctx); - } else { - getFlaskViewDecorator(functionDef).ifPresent(callExpression -> checkFlaskView(callExpression, ctx)); } }); } private static void checkDjangoView(FunctionDef functionDef, SubscriptionContext ctx) { - for (Decorator decorator : functionDef.decorators()) { - if (getSymbolFromTree(decorator.expression()) - .filter(symbol -> symbol.fullyQualifiedName() == null || COMPLIANT_DECORATORS.contains(symbol.fullyQualifiedName())) - .isPresent()) { - return; - } - if (decorator.expression().is(CALL_EXPR)) { - CallExpression callExpression = (CallExpression) decorator.expression(); - Symbol symbol = callExpression.calleeSymbol(); - if (symbol != null && "django.views.decorators.http.require_http_methods".equals(symbol.fullyQualifiedName())) { - checkRequireHttpMethodsDecorator(ctx, callExpression); - return; - } - } - } - ctx.addIssue(functionDef.name(), MESSAGE); - } + boolean hasCompliantDecorator = functionDef.decorators().stream() + .map(Decorator::expression) + .anyMatch(expr -> COMPLIANT_DECORATORS.isTrueFor(expr, ctx) || isCallRequiredHTTPMethod(expr, ctx)); - private static void checkRequireHttpMethodsDecorator(SubscriptionContext ctx, CallExpression callExpression) { - List arguments = callExpression.arguments(); - if (!arguments.isEmpty() && hasBothUnsafeAndSafeHttpMethods(arguments.get(0))) { - ctx.addIssue(callExpression, MESSAGE); - } - } + boolean hasNonDjangoDecorator = functionDef.decorators().stream() + .map(Decorator::expression) + .anyMatch(expr -> !isKnownDjangoDecorator(expr)); - private static boolean hasBothUnsafeAndSafeHttpMethods(Argument argument) { - boolean hasSafeHttpMethod = false; - boolean hasUnsafeHttpMethod = false; - if (argument.is(REGULAR_ARGUMENT) && ((RegularArgument) argument).expression().is(LIST_LITERAL)) { - ListLiteral listLiteral = (ListLiteral) ((RegularArgument) argument).expression(); - for (Expression expression : listLiteral.elements().expressions()) { - if (expression.is(STRING_LITERAL)) { - String value = ((StringLiteral) expression).trimmedQuotesValue(); - if (SAFE_HTTP_METHODS.contains(value)) { - hasSafeHttpMethod = true; - } else if (UNSAFE_HTTP_METHODS.contains(value)) { - hasUnsafeHttpMethod = true; - } - } - } + if (!hasCompliantDecorator && !hasNonDjangoDecorator && !hasRequestMethodCheck(functionDef)) { + ctx.addIssue(functionDef.name(), MESSAGE); } - return hasSafeHttpMethod && hasUnsafeHttpMethod; } - private static boolean isDjangoView(FunctionDef functionDef) { - FunctionSymbol functionSymbol = ((FunctionDefImpl) functionDef).functionSymbol(); - return Optional.ofNullable(functionSymbol) - .map(FunctionSymbolImpl.class::cast) - .filter(FunctionSymbolImpl::isDjangoView) - .isPresent(); + private static boolean isCallRequiredHTTPMethod(Expression expression, SubscriptionContext ctx) { + return expression instanceof CallExpression callExpression && + IS_REQUIRED_HTTP_METHOD.isTrueFor(callExpression.callee(), ctx); } - private static Optional getFlaskViewDecorator(FunctionDef functionDef) { - return functionDef.decorators().stream() - .map(Decorator::expression) - .filter(expression -> expression.is(CALL_EXPR)) - .map(CallExpression.class::cast) - .filter(UnsafeHttpMethodsCheck::isFlaskRouteDecorator) - .findFirst(); + private static boolean isKnownDjangoDecorator(Expression expression) { + var type = expression instanceof CallExpression callExpr + ? callExpr.callee().typeV2() + : expression.typeV2(); + return type instanceof UnknownType.UnresolvedImportType uit && + uit.importPath().startsWith("django."); } - private static boolean isFlaskRouteDecorator(CallExpression callExpression) { - Symbol calleeSymbol = callExpression.calleeSymbol(); - if (calleeSymbol == null) { + private static boolean hasRequestMethodCheck(FunctionDef functionDef) { + var params = functionDef.parameters(); + if (params == null || params.nonTuple().isEmpty()) { + return false; + } + Name firstParam = params.nonTuple().get(0).name(); + if (firstParam == null) { + return false; + } + SymbolV2 symbol = firstParam.symbolV2(); + if (symbol == null) { return false; } - return "route".equals(calleeSymbol.name()); + return symbol.usages().stream() + .filter(usage -> usage.kind() != UsageV2.Kind.PARAMETER) + .anyMatch(UnsafeHttpMethodsCheck::isRequestMethodInIfCondition); } - private static void checkFlaskView(CallExpression callExpression, SubscriptionContext ctx) { - RegularArgument methodsArg = argumentByKeyword("methods", callExpression.arguments()); - if (methodsArg != null && hasBothUnsafeAndSafeHttpMethods(methodsArg) && isFlaskImported(callExpression)) { - ctx.addIssue(callExpression, MESSAGE); + private static boolean isRequestMethodInIfCondition(UsageV2 usage) { + if (!(usage.tree().parent() instanceof QualifiedExpression qe) || !"method".equals(qe.name().name())) { + return false; } + if (!(qe.parent() instanceof BinaryExpression comparison) || + (!comparison.is(Tree.Kind.COMPARISON) && !comparison.is(Tree.Kind.IN))) { + return false; + } + Tree ancestor = comparison.parent(); + while (ancestor instanceof BinaryExpression || ancestor instanceof ParenthesizedExpression) { + ancestor = ancestor.parent(); + } + return ancestor instanceof IfStatement; } - private static boolean isFlaskImported(CallExpression callExpression) { - return Optional.ofNullable(TreeUtils.firstAncestorOfKind(callExpression, FILE_INPUT)) - .filter(fileInput -> ((FileInput) fileInput).globalVariables().stream() - .map(Symbol::fullyQualifiedName) - .filter(Objects::nonNull) - .anyMatch(fqn -> fqn.contains("flask"))) + private static boolean isDjangoView(FunctionDef functionDef) { + FunctionSymbol functionSymbol = ((FunctionDefImpl) functionDef).functionSymbol(); + return Optional.ofNullable(functionSymbol) + .map(FunctionSymbolImpl.class::cast) + .filter(FunctionSymbolImpl::isDjangoView) .isPresent(); } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/UnverifiedHostnameCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/UnverifiedHostnameCheck.java index 60464ba118..405770e663 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/UnverifiedHostnameCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/UnverifiedHostnameCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/XMLSignatureValidationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/XMLSignatureValidationCheck.java index 21d8cbfd7e..47693f38a8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/XMLSignatureValidationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/XMLSignatureValidationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/hotspots/package-info.java b/python-checks/src/main/java/org/sonar/python/checks/hotspots/package-info.java index 0e1767285c..4c74e82e0c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/hotspots/package-info.java +++ b/python-checks/src/main/java/org/sonar/python/checks/hotspots/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/package-info.java b/python-checks/src/main/java/org/sonar/python/checks/package-info.java index 5cc0f09367..9f46952e4b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/package-info.java +++ b/python-checks/src/main/java/org/sonar/python/checks/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/AbstractRedosCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/AbstractRedosCheck.java new file mode 100644 index 0000000000..12e90b4b82 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/AbstractRedosCheck.java @@ -0,0 +1,41 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.regex; + +import java.util.Optional; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonarsource.analyzer.commons.regex.MatchType; +import org.sonarsource.analyzer.commons.regex.RegexParseResult; +import org.sonarsource.analyzer.commons.regex.finders.RedosFinder; + +public abstract class AbstractRedosCheck extends AbstractRegexCheck { + + @Override + public void checkRegex(RegexParseResult regexParseResult, CallExpression regexFunctionCall) { + MatchType matchType = RedosMatchTypeHelper.getMatchTypeFromCalledMethod(regexFunctionCall); + new PythonRedosFinder().checkRegex(regexParseResult, matchType, this::addIssue); + } + + protected abstract Optional buildMessage(RedosFinder.BacktrackingType backtrackingType, boolean regexContainsBackReference); + + private class PythonRedosFinder extends RedosFinder { + @Override + protected Optional message(RedosFinder.BacktrackingType backtrackingType, boolean regexContainsBackReference) { + return buildMessage(backtrackingType, regexContainsBackReference); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/AbstractRegexCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/AbstractRegexCheck.java index 65186cce58..49e500ea22 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/AbstractRegexCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/AbstractRegexCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/AnchorPrecedenceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/AnchorPrecedenceCheck.java index b7730ea9aa..309ed1609f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/AnchorPrecedenceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/AnchorPrecedenceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/DuplicatesInCharacterClassCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/DuplicatesInCharacterClassCheck.java index 77e0921c78..e1a7e0404b 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/DuplicatesInCharacterClassCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/DuplicatesInCharacterClassCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyAlternativeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyAlternativeCheck.java index 7bfffde998..be5b873cb6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyAlternativeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyAlternativeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyGroupCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyGroupCheck.java index 8866cfa209..27adfc0bd7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyGroupCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyGroupCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyStringRepetitionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyStringRepetitionCheck.java index 5ecd2316e4..bef9e1bfda 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyStringRepetitionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/EmptyStringRepetitionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/GraphemeClustersInClassesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/GraphemeClustersInClassesCheck.java index 51c8af080a..8a48bf8c78 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/GraphemeClustersInClassesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/GraphemeClustersInClassesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/GroupReplacementCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/GroupReplacementCheck.java index 326e1620ee..53976663ad 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/GroupReplacementCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/GroupReplacementCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/ImpossibleBackReferenceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/ImpossibleBackReferenceCheck.java index 935053b065..96364f6e2d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/ImpossibleBackReferenceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/ImpossibleBackReferenceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/ImpossibleBoundariesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/ImpossibleBoundariesCheck.java index 2c4df04b59..1e4f665543 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/ImpossibleBoundariesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/ImpossibleBoundariesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/InvalidRegexCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/InvalidRegexCheck.java index f2dbe03478..89610a51b6 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/InvalidRegexCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/InvalidRegexCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/MultipleWhitespaceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/MultipleWhitespaceCheck.java index 70a5adde66..5d4655aa10 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/MultipleWhitespaceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/MultipleWhitespaceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/OctalEscapeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/OctalEscapeCheck.java index cbf626adde..6bb8a35dd8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/OctalEscapeCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/OctalEscapeCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/PossessiveQuantifierContinuationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/PossessiveQuantifierContinuationCheck.java index 653d0acb20..cb27a1250a 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/PossessiveQuantifierContinuationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/PossessiveQuantifierContinuationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/RedosCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/RedosCheck.java index ff7a16da07..b449784c6f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/RedosCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/RedosCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -18,111 +18,23 @@ import java.util.Optional; -import java.util.Set; -import java.util.function.Predicate; import org.sonar.check.Rule; -import org.sonar.plugins.python.api.symbols.Symbol; -import org.sonar.plugins.python.api.symbols.Usage; -import org.sonar.plugins.python.api.tree.AssignmentStatement; -import org.sonar.plugins.python.api.tree.CallExpression; -import org.sonar.plugins.python.api.tree.HasSymbol; -import org.sonar.plugins.python.api.tree.Name; -import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.tree.TreeUtils; -import org.sonarsource.analyzer.commons.regex.MatchType; -import org.sonarsource.analyzer.commons.regex.RegexParseResult; import org.sonarsource.analyzer.commons.regex.finders.RedosFinder; - @Rule(key = "S5852") -public class RedosCheck extends AbstractRegexCheck { +public class RedosCheck extends AbstractRedosCheck { private static final String MESSAGE = """ Make sure the regex used here, which is vulnerable to %s runtime due to backtracking,\ cannot lead to denial of service."""; private static final String EXP = "exponential"; - private static final String POLY = "polynomial"; - private static final Set FULL_MATCH_METHODS = Set.of("fullmatch"); - private static final Set PARTIAL_MATCH_METHODS = Set.of("findall", "search", "split", "sub", "subn"); - private static final String COMPILE_METHOD = "compile"; @Override - public void checkRegex(RegexParseResult regexParseResult, CallExpression regexFunctionCall) { - MatchType matchType = getMatchTypeFromCalledMethod(regexFunctionCall); - new PythonRedosFinder().checkRegex(regexParseResult, matchType, this::addIssue); - } - - private static MatchType getMatchTypeFromCalledMethod(CallExpression regexFunctionCall) { - Symbol symbol = regexFunctionCall.calleeSymbol(); - if (symbol == null) { - // Defensive, callee symbol should have been checked prior to calling "checkRegex" - return MatchType.UNKNOWN; - } - if (FULL_MATCH_METHODS.contains(symbol.name())) { - return MatchType.FULL; - } - if (PARTIAL_MATCH_METHODS.contains(symbol.name())) { - return MatchType.PARTIAL; - } - if (COMPILE_METHOD.equals(symbol.name())) { - return matchTypeOfCompiledPattern(regexFunctionCall); - } - return MatchType.UNKNOWN; - } - - private static MatchType matchTypeOfCompiledPattern(CallExpression regexFunctionCall) { - return Optional.ofNullable(TreeUtils.firstAncestorOfKind(regexFunctionCall, Tree.Kind.ASSIGNMENT_STMT)) - .map(AssignmentStatement.class::cast) - .map(a -> a.lhsExpressions().get(0).expressions().get(0)) - .filter(lhs -> lhs.is(Tree.Kind.NAME)) - .map(n -> (Name) n) - .map(HasSymbol::symbol) - .map(RedosCheck::getMatchTypeFromSymbolUsages) - .orElse(MatchType.UNKNOWN); - } - - private static MatchType getMatchTypeFromSymbolUsages(Symbol s) { - boolean isUsedForFullMatch = s.usages().stream().map(Usage::tree).anyMatch(t -> isUsedInMethod(t, FULL_MATCH_METHODS)); - boolean isUsedForPartialMatch = s.usages().stream().map(Usage::tree).anyMatch(t -> isUsedInMethod(t, PARTIAL_MATCH_METHODS)); - return getMatchType(isUsedForFullMatch, isUsedForPartialMatch); - } - - private static MatchType getMatchType(boolean isUsedForFullMatch, boolean isUsedForPartialMatch) { - if (isUsedForFullMatch && isUsedForPartialMatch) { - return MatchType.BOTH; - } - if (isUsedForFullMatch) { - return MatchType.FULL; - } - if (isUsedForPartialMatch) { - return MatchType.PARTIAL; - } - return MatchType.UNKNOWN; - } - - private static boolean isUsedInMethod(Tree tree, Set methodNames) { - return TreeUtils.firstAncestor(tree, isCallToMethod(methodNames)) != null; - } - - private static Predicate isCallToMethod(Set methodNames) { - return tree -> Optional.ofNullable(tree) - .filter(t -> t.is(Tree.Kind.CALL_EXPR)) - .map(CallExpression.class::cast) - .map(CallExpression::calleeSymbol) - .map(Symbol::name) - .filter(methodNames::contains) - .isPresent(); - } - - static class PythonRedosFinder extends RedosFinder { - - @Override - protected Optional message(RedosFinder.BacktrackingType backtrackingType, boolean regexContainsBackReference) { - return switch (backtrackingType) { - case ALWAYS_EXPONENTIAL, QUADRATIC_WHEN_OPTIMIZED, LINEAR_WHEN_OPTIMIZED -> Optional.of(String.format(MESSAGE, EXP)); - case ALWAYS_QUADRATIC -> Optional.of(String.format(MESSAGE, POLY)); - default -> Optional.empty(); - }; - } + protected Optional buildMessage(RedosFinder.BacktrackingType backtrackingType, boolean regexContainsBackReference) { + return switch (backtrackingType) { + // Python has no JIT-style optimisation for QUADRATIC_WHEN_OPTIMIZED or LINEAR_WHEN_OPTIMIZED, so it stays in S5852 + case ALWAYS_EXPONENTIAL, QUADRATIC_WHEN_OPTIMIZED, LINEAR_WHEN_OPTIMIZED -> Optional.of(String.format(MESSAGE, EXP)); + default -> Optional.empty(); + }; } } diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/RedosMatchTypeHelper.java b/python-checks/src/main/java/org/sonar/python/checks/regex/RedosMatchTypeHelper.java new file mode 100644 index 0000000000..3be43f6de0 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/RedosMatchTypeHelper.java @@ -0,0 +1,102 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.regex; + +import java.util.Optional; +import java.util.Set; +import java.util.function.Predicate; +import org.sonar.plugins.python.api.symbols.Symbol; +import org.sonar.plugins.python.api.symbols.Usage; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.HasSymbol; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.python.tree.TreeUtils; +import org.sonarsource.analyzer.commons.regex.MatchType; + +final class RedosMatchTypeHelper { + + private static final Set FULL_MATCH_METHODS = Set.of("fullmatch"); + private static final Set PARTIAL_MATCH_METHODS = Set.of("findall", "search", "split", "sub", "subn"); + private static final String COMPILE_METHOD = "compile"; + + private RedosMatchTypeHelper() { + } + + static MatchType getMatchTypeFromCalledMethod(CallExpression regexFunctionCall) { + Symbol symbol = regexFunctionCall.calleeSymbol(); + if (symbol == null) { + // Defensive: callee symbol should have been checked prior to calling "checkRegex" + return MatchType.UNKNOWN; + } + if (FULL_MATCH_METHODS.contains(symbol.name())) { + return MatchType.FULL; + } + if (PARTIAL_MATCH_METHODS.contains(symbol.name())) { + return MatchType.PARTIAL; + } + if (COMPILE_METHOD.equals(symbol.name())) { + return matchTypeOfCompiledPattern(regexFunctionCall); + } + return MatchType.UNKNOWN; + } + + private static MatchType matchTypeOfCompiledPattern(CallExpression regexFunctionCall) { + return Optional.ofNullable(TreeUtils.firstAncestorOfKind(regexFunctionCall, Tree.Kind.ASSIGNMENT_STMT)) + .map(AssignmentStatement.class::cast) + .map(a -> a.lhsExpressions().get(0).expressions().get(0)) + .filter(lhs -> lhs.is(Tree.Kind.NAME)) + .map(n -> (Name) n) + .map(HasSymbol::symbol) + .map(RedosMatchTypeHelper::getMatchTypeFromSymbolUsages) + .orElse(MatchType.UNKNOWN); + } + + private static MatchType getMatchTypeFromSymbolUsages(Symbol s) { + boolean isUsedForFullMatch = s.usages().stream().map(Usage::tree).anyMatch(t -> isUsedInMethod(t, FULL_MATCH_METHODS)); + boolean isUsedForPartialMatch = s.usages().stream().map(Usage::tree).anyMatch(t -> isUsedInMethod(t, PARTIAL_MATCH_METHODS)); + return getMatchType(isUsedForFullMatch, isUsedForPartialMatch); + } + + private static MatchType getMatchType(boolean isUsedForFullMatch, boolean isUsedForPartialMatch) { + if (isUsedForFullMatch && isUsedForPartialMatch) { + return MatchType.BOTH; + } + if (isUsedForFullMatch) { + return MatchType.FULL; + } + if (isUsedForPartialMatch) { + return MatchType.PARTIAL; + } + return MatchType.UNKNOWN; + } + + private static boolean isUsedInMethod(Tree tree, Set methodNames) { + return TreeUtils.firstAncestor(tree, isCallToMethod(methodNames)) != null; + } + + private static Predicate isCallToMethod(Set methodNames) { + return tree -> Optional.ofNullable(tree) + .filter(t -> t.is(Tree.Kind.CALL_EXPR)) + .map(CallExpression.class::cast) + .map(CallExpression::calleeSymbol) + .map(Symbol::name) + .filter(methodNames::contains) + .isPresent(); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/RedundantRegexAlternativesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/RedundantRegexAlternativesCheck.java index dcde32090d..2f5610c6fc 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/RedundantRegexAlternativesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/RedundantRegexAlternativesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/RegexComplexityCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/RegexComplexityCheck.java index cf5ac16707..8788dcb85f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/RegexComplexityCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/RegexComplexityCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/RegexLookaheadCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/RegexLookaheadCheck.java index fc0839e3df..3e02563798 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/RegexLookaheadCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/RegexLookaheadCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/ReluctantQuantifierCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/ReluctantQuantifierCheck.java index c6f3ad2389..7ff945c370 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/ReluctantQuantifierCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/ReluctantQuantifierCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/ReluctantQuantifierWithEmptyContinuationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/ReluctantQuantifierWithEmptyContinuationCheck.java index a6c571af7e..c12e31fab8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/ReluctantQuantifierWithEmptyContinuationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/ReluctantQuantifierWithEmptyContinuationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/SingleCharCharacterClassCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/SingleCharCharacterClassCheck.java index a819a0a71c..1a37391d03 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/SingleCharCharacterClassCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/SingleCharCharacterClassCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/SingleCharacterAlternationCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/SingleCharacterAlternationCheck.java index 7a10cd1edf..c0597b2767 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/SingleCharacterAlternationCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/SingleCharacterAlternationCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/StringReplaceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/StringReplaceCheck.java index 1b018f385b..b436d9b21f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/StringReplaceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/StringReplaceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/SuperLinearRegexCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/SuperLinearRegexCheck.java new file mode 100644 index 0000000000..0214cd3df1 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/SuperLinearRegexCheck.java @@ -0,0 +1,36 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.regex; + + +import java.util.Optional; +import org.sonar.check.Rule; +import org.sonarsource.analyzer.commons.regex.finders.RedosFinder; + +@Rule(key = "S8786") +public class SuperLinearRegexCheck extends AbstractRedosCheck { + + private static final String MESSAGE = "Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking."; + + @Override + protected Optional buildMessage(RedosFinder.BacktrackingType backtrackingType, boolean regexContainsBackReference) { + return switch (backtrackingType) { + case ALWAYS_QUADRATIC -> Optional.of(MESSAGE); + default -> Optional.empty(); + }; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/SuperfluousCurlyBraceCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/SuperfluousCurlyBraceCheck.java index af46cba32b..c141a01b1f 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/SuperfluousCurlyBraceCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/SuperfluousCurlyBraceCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/UnquantifiedNonCapturingGroupCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/UnquantifiedNonCapturingGroupCheck.java index eb3f9c456a..2227684236 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/UnquantifiedNonCapturingGroupCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/UnquantifiedNonCapturingGroupCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/UnusedGroupNamesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/UnusedGroupNamesCheck.java index fdf5552108..9c50fb6ae1 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/UnusedGroupNamesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/UnusedGroupNamesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/VerboseRegexCheck.java b/python-checks/src/main/java/org/sonar/python/checks/regex/VerboseRegexCheck.java index b58f24879a..901c835e6d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/VerboseRegexCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/VerboseRegexCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/regex/package-info.java b/python-checks/src/main/java/org/sonar/python/checks/regex/package-info.java index e9a845108d..7938242d43 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/regex/package-info.java +++ b/python-checks/src/main/java/org/sonar/python/checks/regex/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/AssertAfterRaiseCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertAfterRaiseCheck.java index 553a2d9250..0bb6089c0e 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/tests/AssertAfterRaiseCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertAfterRaiseCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -34,7 +34,7 @@ import org.sonar.plugins.python.api.quickfix.PythonQuickFix; import org.sonar.plugins.python.api.quickfix.PythonTextEdit; import org.sonar.python.quickfix.TextEditUtils; -import org.sonar.python.tests.UnittestUtils; +import org.sonar.python.checks.utils.UnittestUtils; import org.sonar.python.tree.TreeUtils; @Rule(key = "S5915") diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/AssertOnDissimilarTypesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertOnDissimilarTypesCheck.java index ece9bdf907..061b3c1e98 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/tests/AssertOnDissimilarTypesCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertOnDissimilarTypesCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -35,7 +35,7 @@ import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.plugins.python.api.types.InferredType; -import org.sonar.python.tests.UnittestUtils; +import org.sonar.python.checks.utils.UnittestUtils; import org.sonar.python.tree.TreeUtils; import org.sonar.python.types.InferredTypes; diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/AssertOnTupleLiteralCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertOnTupleLiteralCheck.java index 559bf717d9..274e8190e7 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/tests/AssertOnTupleLiteralCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertOnTupleLiteralCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/AssertionArgumentOrderCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertionArgumentOrderCheck.java new file mode 100644 index 0000000000..5d79839702 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertionArgumentOrderCheck.java @@ -0,0 +1,306 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.IssueLocation; +import org.sonar.plugins.python.api.PythonCheck; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.TokenLocation; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.quickfix.PythonTextEdit; +import org.sonar.plugins.python.api.tree.AssertStatement; +import org.sonar.plugins.python.api.tree.BinaryExpression; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.UnittestUtils; +import org.sonar.python.checks.utils.UnittestUtils.AssertionArguments; +import org.sonar.python.checks.utils.UnittestUtils.AssertionFrameworkHandlers; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.TreeUtils; + +import static org.sonar.python.checks.utils.UnittestUtils.ASSERTPY_IS_EQUAL_TO_MATCHER; +import static org.sonar.python.checks.utils.UnittestUtils.PYTEST_APPROX_MATCHER; + +@Rule(key = "S3415") +public class AssertionArgumentOrderCheck extends PythonSubscriptionCheck { + private static final String MESSAGE = "Unify assertion argument order in this file; both \"actual first\" and \"expected first\" conventions are used."; + private static final String ACTUAL_FIRST_FLOW = "Actual value first"; + private static final String EXPECTED_FIRST_FLOW = "Expected value first"; + private static final String ACTUAL_FIRST_LOCATION_MESSAGE = "Actual value first."; + private static final String EXPECTED_FIRST_LOCATION_MESSAGE = "Expected value first."; + private static final String PUT_EXPECTED_SECOND_QF = "Put all expected values second"; + private static final String PUT_ACTUAL_SECOND_QF = "Put all actual values second"; + private static final String PYTEST_APPROX_EXPECTED_ARGUMENT_NAME = "expected"; + + private enum Convention { + ACTUAL_FIRST, + EXPECTED_FIRST + } + + private final List assertions = new ArrayList<>(); + private SubscriptionContext subscriptionContext; + + private record OrderableAssertion( + Tree primaryLocation, + Convention convention, + List swapEdits) { + } + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> { + assertions.clear(); + subscriptionContext = ctx; + }); + UnittestUtils.registerAssertionSyntaxNodeConsumers(context, new AssertionFrameworkHandlers( + this::checkUnittestAssertion, + this::checkAssertpyAssertion, + this::checkPytestAssertion)); + } + + @Override + public void leaveFile() { + if (subscriptionContext == null) { + return; + } + + List actualFirst = assertions.stream().filter(a -> a.convention() == Convention.ACTUAL_FIRST).toList(); + List expectedFirst = assertions.stream().filter(a -> a.convention() == Convention.EXPECTED_FIRST).toList(); + if (actualFirst.isEmpty() || expectedFirst.isEmpty()) { + return; + } + + OrderableAssertion primary = assertions.get(0); + PythonCheck.PreciseIssue issue = subscriptionContext.addIssue(primary.primaryLocation(), MESSAGE); + issue.addFlow(ACTUAL_FIRST_FLOW, toFlowLocations(actualFirst, ACTUAL_FIRST_LOCATION_MESSAGE)); + issue.addFlow(EXPECTED_FIRST_FLOW, toFlowLocations(expectedFirst, EXPECTED_FIRST_LOCATION_MESSAGE)); + createUnifyQuickFix(PUT_EXPECTED_SECOND_QF, expectedFirst).ifPresent(issue::addQuickFix); + createUnifyQuickFix(PUT_ACTUAL_SECOND_QF, actualFirst).ifPresent(issue::addQuickFix); + } + + @Override + public CheckScope scope() { + return CheckScope.TESTS; + } + + private void checkUnittestAssertion(SubscriptionContext ctx, CallExpression callExpression) { + AssertionArguments arguments = UnittestUtils.unittestAssertionArguments(callExpression, ctx); + if (arguments == null) { + return; + } + classifyAndCollect(callExpression, arguments.actual(), arguments.expected(), ctx); + } + + private void checkPytestAssertion(SubscriptionContext ctx, AssertStatement assertStatement) { + if (!UnittestUtils.isPytestStyleTestFunction(ctx, assertStatement)) { + return; + } + + Expression condition = Expressions.removeParentheses(assertStatement.condition()); + if (!(condition instanceof BinaryExpression binaryExpression) || !"==".equals(binaryExpression.operator().value())) { + return; + } + + Expression left = binaryExpression.leftOperand(); + Expression right = binaryExpression.rightOperand(); + boolean leftExpected = isExpectedValue(left, ctx); + boolean rightExpected = isExpectedValue(right, ctx); + if (leftExpected == rightExpected) { + return; + } + + Convention convention = leftExpected ? Convention.EXPECTED_FIRST : Convention.ACTUAL_FIRST; + List swapEdits = createPytestSwapEdits(binaryExpression, convention, ctx); + assertions.add(new OrderableAssertion(condition, convention, swapEdits)); + } + + private void checkAssertpyAssertion(SubscriptionContext ctx, CallExpression callExpression) { + AssertionArguments arguments = UnittestUtils.assertpyAssertionArguments(callExpression, ctx, ASSERTPY_IS_EQUAL_TO_MATCHER); + if (arguments == null) { + return; + } + classifyAndCollect(callExpression, arguments.actual(), arguments.expected(), ctx); + } + + private void classifyAndCollect(Tree primaryLocation, Expression firstPosition, Expression secondPosition, SubscriptionContext ctx) { + boolean firstExpected = isExpectedValue(firstPosition, ctx); + boolean secondExpected = isExpectedValue(secondPosition, ctx); + if (firstExpected == secondExpected) { + return; + } + Convention convention = firstExpected ? Convention.EXPECTED_FIRST : Convention.ACTUAL_FIRST; + assertions.add(new OrderableAssertion(primaryLocation, convention, createSwapEdits(firstPosition, secondPosition, ctx))); + } + + private static List toFlowLocations(List group, String message) { + return group.stream() + .map(assertion -> IssueLocation.preciseLocation(assertion.primaryLocation(), message)) + .toList(); + } + + private static Optional createUnifyQuickFix(String description, List toSwap) { + // Only offer a unify fix when every assertion in the group can be edited; otherwise applying a + // partial fix would leave the file still mixing conventions. + if (toSwap.stream().anyMatch(assertion -> assertion.swapEdits().isEmpty())) { + return Optional.empty(); + } + List edits = toSwap.stream().flatMap(assertion -> assertion.swapEdits().stream()).toList(); + return Optional.of(PythonQuickFix.newQuickFix(description).addTextEdit(edits).build()); + } + + private static List createSwapEdits(Expression leftExpression, Expression rightExpression, SubscriptionContext ctx) { + String leftText = expressionText(leftExpression, ctx); + String rightText = expressionText(rightExpression, ctx); + if (leftText == null || rightText == null) { + return List.of(); + } + return List.of( + TextEditUtils.replace(leftExpression, rightText), + TextEditUtils.replace(rightExpression, leftText)); + } + + private static List createPytestSwapEdits(BinaryExpression binaryExpression, Convention convention, SubscriptionContext ctx) { + Expression left = binaryExpression.leftOperand(); + Expression right = binaryExpression.rightOperand(); + Expression expectedOperand = convention == Convention.EXPECTED_FIRST ? left : right; + Expression actualOperand = convention == Convention.EXPECTED_FIRST ? right : left; + + // expected == approx(actual) (or mirrored): unwrap by swapping the constant with the approx argument + CallExpression approxWrappingActual = asPytestApproxCall(actualOperand, ctx); + if (approxWrappingActual != null) { + RegularArgument approxExpectedArg = TreeUtils.nthArgumentOrKeyword(0, PYTEST_APPROX_EXPECTED_ARGUMENT_NAME, approxWrappingActual.arguments()); + if (approxExpectedArg == null) { + return List.of(); + } + String replacementForExpectedOperand = expressionText(approxExpectedArg.expression(), ctx); + String replacementForApproxArg = expressionText(expectedOperand, ctx); + if (replacementForExpectedOperand == null || replacementForApproxArg == null) { + return List.of(); + } + return List.of( + TextEditUtils.replace(expectedOperand, replacementForExpectedOperand), + TextEditUtils.replace(approxExpectedArg.expression(), replacementForApproxArg)); + } + + return createSwapEdits(left, right, ctx); + } + + @Nullable + private static CallExpression asPytestApproxCall(Expression expression, SubscriptionContext ctx) { + Expression normalized = Expressions.removeParentheses(expression); + if (normalized instanceof CallExpression callExpression && PYTEST_APPROX_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return callExpression; + } + return null; + } + + @Nullable + private static String expressionText(Expression expression, SubscriptionContext ctx) { + String fileContent = ctx.pythonFile().content(); + int startIndex = convertPositionToIndex(fileContent, expression.firstToken().line(), expression.firstToken().column()); + TokenLocation endLocation = new TokenLocation(expression.lastToken()); + int endIndex = convertPositionToIndex(fileContent, endLocation.endLine(), endLocation.endLineOffset()); + if (startIndex < 0 || endIndex < startIndex || endIndex > fileContent.length()) { + return null; + } + return fileContent.substring(startIndex, endIndex); + } + + private static int convertPositionToIndex(String fileContent, int line, int lineOffset) { + int currentIndex = 0; + int currentLine = 1; + + while (currentLine < line && currentIndex < fileContent.length()) { + int nextIndex = nextIndex(fileContent, currentIndex); + if (isLineBreak(fileContent.charAt(currentIndex))) { + currentLine++; + } + currentIndex = nextIndex; + } + + if (currentLine != line) { + return -1; + } + + int lineEnd = findLineEnd(fileContent, currentIndex); + + if (lineOffset < 0 || currentIndex + lineOffset > lineEnd) { + return -1; + } + return currentIndex + lineOffset; + } + + private static int nextIndex(String fileContent, int currentIndex) { + char current = fileContent.charAt(currentIndex); + currentIndex++; + if (current == '\r') { + if (currentIndex < fileContent.length() && fileContent.charAt(currentIndex) == '\n') { + return currentIndex + 1; + } + return currentIndex; + } + if (current == '\n') { + return currentIndex; + } + return currentIndex; + } + + private static int findLineEnd(String fileContent, int currentIndex) { + int lineEnd = currentIndex; + while (lineEnd < fileContent.length() && !isLineBreak(fileContent.charAt(lineEnd))) { + lineEnd++; + } + return lineEnd; + } + + private static boolean isLineBreak(char current) { + return current == '\r' || current == '\n'; + } + + private static boolean isExpectedValue(Expression expression, SubscriptionContext ctx) { + Expression unwrapped = Expressions.removeParentheses(expression); + if (CheckUtils.isConstant(unwrapped)) { + return true; + } + if (isPytestApproxExpectedValue(unwrapped, ctx)) { + return true; + } + if (unwrapped instanceof Name name) { + return Expressions.singleAssignedNonNameValue(name).filter(CheckUtils::isImmutableConstant).isPresent(); + } + return false; + } + + private static boolean isPytestApproxExpectedValue(Expression expression, SubscriptionContext ctx) { + if (!(expression instanceof CallExpression callExpression) || !PYTEST_APPROX_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return false; + } + RegularArgument expectedArg = TreeUtils.nthArgumentOrKeyword(0, PYTEST_APPROX_EXPECTED_ARGUMENT_NAME, callExpression.arguments()); + return expectedArg != null && isExpectedValue(expectedArg.expression(), ctx); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/AssertionInTryCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertionInTryCheck.java new file mode 100644 index 0000000000..f01043ee3f --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/AssertionInTryCheck.java @@ -0,0 +1,242 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import java.util.Map; +import java.util.Optional; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ExceptClause; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionStatement; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RaiseStatement; +import org.sonar.plugins.python.api.tree.StatementList; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.TryStatement; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.AssertpyUtils; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.UnittestUtils; +import org.sonar.python.tree.TreeUtils; + +import static org.sonar.plugins.python.api.types.BuiltinTypes.BASE_EXCEPTION; +import static org.sonar.plugins.python.api.types.BuiltinTypes.EXCEPTION; + +@Rule(key = "S5779") +public class AssertionInTryCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Don't use %s inside a try-except that catches AssertionError."; + private static final String ASSERTION_ERROR_SECONDARY_MESSAGE = "AssertionError is caught here."; + private static final String EXCEPTION_SECONDARY_MESSAGE = "Exception is caught here."; + private static final String BASE_EXCEPTION_SECONDARY_MESSAGE = "BaseException is caught here."; + private static final String BARE_EXCEPT_SECONDARY_MESSAGE = "All exceptions are caught here."; + + private static final TypeMatcher ASSERTION_ERROR_TYPE_MATCHER = TypeMatchers.any( + TypeMatchers.isType("AssertionError"), + TypeMatchers.isOrExtendsType("builtins.AssertionError")); + private static final TypeMatcher EXCEPTION_TYPE_MATCHER = TypeMatchers.any( + TypeMatchers.isObjectOfType(EXCEPTION), + TypeMatchers.isType(EXCEPTION)); + private static final TypeMatcher BASE_EXCEPTION_TYPE_MATCHER = TypeMatchers.any( + TypeMatchers.isObjectOfType(BASE_EXCEPTION), + TypeMatchers.isType(BASE_EXCEPTION)); + private static final TypeMatcher CATCHES_ASSERTION_ERROR_MATCHER = TypeMatchers.any( + ASSERTION_ERROR_TYPE_MATCHER, + EXCEPTION_TYPE_MATCHER, + BASE_EXCEPTION_TYPE_MATCHER); + private static final List> SECONDARY_MESSAGES_BY_EXCEPTION_TYPE = List.of( + Map.entry(ASSERTION_ERROR_TYPE_MATCHER, ASSERTION_ERROR_SECONDARY_MESSAGE), + Map.entry(EXCEPTION_TYPE_MATCHER, EXCEPTION_SECONDARY_MESSAGE), + Map.entry(BASE_EXCEPTION_TYPE_MATCHER, BASE_EXCEPTION_SECONDARY_MESSAGE)); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.ASSERT_STMT, ctx -> checkAssertion(ctx, ctx.syntaxNode(), "assert")); + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> checkCallExpression(ctx, (CallExpression) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkCallExpression(SubscriptionContext ctx, CallExpression callExpression) { + String assertionName = unittestAssertionName(callExpression); + if (assertionName == null) { + assertionName = assertpyAssertionName(callExpression, ctx); + } + if (assertionName != null) { + checkAssertion(ctx, callExpression, assertionName); + } + } + + private static void checkAssertion(SubscriptionContext ctx, Tree assertion, String assertionName) { + findTrySwallowingAssertionError(assertion, ctx).ifPresent(tryStatement -> { + ExceptClause exceptClause = exceptClauseCatchingAssertionError(tryStatement, ctx); + ctx.addIssue(assertion, String.format(MESSAGE, assertionName)) + .secondary(exceptClause.exception() != null ? exceptClause.exception() : exceptClause.exceptKeyword(), + secondaryMessage(exceptClause, ctx)); + }); + } + + private static Optional findTrySwallowingAssertionError(Tree tree, SubscriptionContext ctx) { + TryStatement tryStatement = enclosingTryStatementInBody(tree); + while (tryStatement != null) { + ExceptClause exceptClause = exceptClauseCatchingAssertionError(tryStatement, ctx); + if (exceptClause != null && !exceptClauseReraises(exceptClause)) { + return Optional.of(tryStatement); + } + tryStatement = enclosingTryStatementInBody(tryStatement); + } + return Optional.empty(); + } + + @Nullable + private static TryStatement enclosingTryStatementInBody(Tree tree) { + TryStatement tryStatement = (TryStatement) TreeUtils.firstAncestorOfKind(tree, Tree.Kind.TRY_STMT); + while (tryStatement != null) { + if (isDescendantOf(tryStatement.body(), tree)) { + return tryStatement; + } + tryStatement = (TryStatement) TreeUtils.firstAncestorOfKind(tryStatement.parent(), Tree.Kind.TRY_STMT); + } + return null; + } + + @Nullable + private static ExceptClause exceptClauseCatchingAssertionError(TryStatement tryStatement, SubscriptionContext ctx) { + for (ExceptClause exceptClause : tryStatement.exceptClauses()) { + if (exceptClause.starToken() != null) { + continue; + } + Expression exception = exceptClause.exception(); + if (exception == null) { + return exceptClause; + } + for (Expression caughtException : TreeUtils.flattenTuples(exception).toList()) { + if (canCatchAssertionError(caughtException, ctx)) { + return exceptClause; + } + } + } + return null; + } + + private static boolean canCatchAssertionError(Expression caughtException, SubscriptionContext ctx) { + return CATCHES_ASSERTION_ERROR_MATCHER.isTrueFor(Expressions.removeParentheses(caughtException), ctx); + } + + private static boolean exceptClauseReraises(ExceptClause exceptClause) { + return TreeUtils.hasDescendant(exceptClause.body(), tree -> { + if (!tree.is(Tree.Kind.RAISE_STMT)) { + return false; + } + RaiseStatement raiseStatement = (RaiseStatement) tree; + if (raiseStatement.expressions().isEmpty()) { + return true; + } + if (exceptClause.exceptionInstance() == null || raiseStatement.expressions().size() != 1) { + return false; + } + return CheckUtils.areEquivalent( + Expressions.removeParentheses(exceptClause.exceptionInstance()), + Expressions.removeParentheses(raiseStatement.expressions().get(0))); + }); + } + + private static String secondaryMessage(ExceptClause exceptClause, SubscriptionContext ctx) { + Expression exception = exceptClause.exception(); + if (exception == null) { + return BARE_EXCEPT_SECONDARY_MESSAGE; + } + for (Expression caughtException : TreeUtils.flattenTuples(exception).toList()) { + String message = secondaryMessageForException(Expressions.removeParentheses(caughtException), ctx); + if (message != null) { + return message; + } + } + return ASSERTION_ERROR_SECONDARY_MESSAGE; + } + + @Nullable + private static String secondaryMessageForException(Expression caughtException, SubscriptionContext ctx) { + return SECONDARY_MESSAGES_BY_EXCEPTION_TYPE.stream() + .filter(entry -> entry.getKey().isTrueFor(caughtException, ctx)) + .map(Map.Entry::getValue) + .findFirst() + .orElse(null); + } + + @Nullable + private static String unittestAssertionName(CallExpression callExpression) { + ExpressionStatement parent = parentExpressionStatement(callExpression); + if (parent == null || parent.expressions().size() != 1) { + return null; + } + Expression callee = Expressions.removeParentheses(callExpression.callee()); + if (!(callee instanceof QualifiedExpression qualifiedExpression)) { + return null; + } + if (!(qualifiedExpression.qualifier() instanceof Name qualifier) || !"self".equals(qualifier.name())) { + return null; + } + String methodName = qualifiedExpression.name().name(); + return UnittestUtils.allAssertMethods().contains(methodName) ? methodName : null; + } + + @Nullable + private static String assertpyAssertionName(CallExpression callExpression, SubscriptionContext ctx) { + ExpressionStatement parent = parentExpressionStatement(callExpression); + if (parent == null) { + return null; + } + if (AssertpyUtils.isAssertThatCall(callExpression, ctx)) { + if (callExpression.parent().is(Tree.Kind.QUALIFIED_EXPR)) { + return null; + } + return "assert_that"; + } + Expression callee = Expressions.removeParentheses(callExpression.callee()); + if (!(callee instanceof QualifiedExpression qualifiedExpression)) { + return null; + } + if (AssertpyUtils.originatingAssertThatCall(qualifiedExpression.qualifier(), ctx) == null) { + return null; + } + return qualifiedExpression.name().name(); + } + + @Nullable + private static ExpressionStatement parentExpressionStatement(CallExpression callExpression) { + if (!(callExpression.parent() instanceof ExpressionStatement expressionStatement)) { + return null; + } + return expressionStatement; + } + + private static boolean isDescendantOf(StatementList statementList, Tree tree) { + return TreeUtils.hasDescendant(statementList, descendant -> descendant == tree); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/CompositeAssertionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/CompositeAssertionCheck.java new file mode 100644 index 0000000000..2a71a13871 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/CompositeAssertionCheck.java @@ -0,0 +1,64 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AssertStatement; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.UnaryExpression; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.UnittestUtils; + +@Rule(key = "S9073") +public class CompositeAssertionCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Split this composite assertion into separate assertions."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.ASSERT_STMT, ctx -> checkAssert(ctx, (AssertStatement) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkAssert(SubscriptionContext ctx, AssertStatement assertStatement) { + if (!UnittestUtils.isPytestFileName(ctx.pythonFile().fileName()) + && !UnittestUtils.isSupportedTestFunction(ctx, assertStatement)) { + return; + } + + Expression condition = Expressions.removeParentheses(assertStatement.condition()); + + if (condition.is(Tree.Kind.AND)) { + ctx.addIssue(assertStatement, MESSAGE); + return; + } + + if (condition.is(Tree.Kind.NOT)) { + Expression inner = Expressions.removeParentheses(((UnaryExpression) condition).expression()); + if (inner.is(Tree.Kind.OR)) { + ctx.addIssue(assertStatement, MESSAGE); + } + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/DedicatedAssertionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/DedicatedAssertionCheck.java index dfb681ea96..952592f658 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/tests/DedicatedAssertionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/DedicatedAssertionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -33,7 +33,7 @@ import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; import org.sonar.python.checks.utils.Expressions; -import org.sonar.python.tests.UnittestUtils; +import org.sonar.python.checks.utils.UnittestUtils; import org.sonar.python.tree.TreeUtils; diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/DedicatedExceptionAssertionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/DedicatedExceptionAssertionCheck.java new file mode 100644 index 0000000000..4688b66611 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/DedicatedExceptionAssertionCheck.java @@ -0,0 +1,150 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ElseClause; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionStatement; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.TryStatement; +import org.sonar.plugins.python.api.tree.Token; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S8714") +public class DedicatedExceptionAssertionCheck extends PythonSubscriptionCheck { + private static final TypeMatcher PYTEST_FAIL_MATCHER = TypeMatchers.withFQN("pytest.fail"); + private static final TypeMatcher UNITTEST_FAIL_MATCHER = TypeMatchers.withFQN("unittest.case.TestCase.fail"); + private static final String PYTEST_MESSAGE = "Replace this try/except block with a \"pytest.raises\" context manager."; + private static final String UNITTEST_MESSAGE = "Replace this try/except block with \"self.assertRaises()\"."; + private static final String NO_EXCEPTION_MESSAGE = "Remove this try/except block and let the test fail naturally if an exception is raised."; + private static final String DEDICATED_ASSERTION_SECONDARY_MESSAGE = "Replace this fail call with a dedicated exception assertion."; + private static final String NO_EXCEPTION_SECONDARY_MESSAGE = "Remove this fail call and let the test fail naturally if an exception is raised."; + + private record FailCall(CallExpression callExpression, String primaryMessage, String secondaryMessage) { + } + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.TRY_STMT, ctx -> checkTryStatement(ctx, (TryStatement) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkTryStatement(SubscriptionContext ctx, TryStatement tryStatement) { + if (!hasSupportedExceptClauses(tryStatement) || tryStatement.finallyClause() != null) { + return; + } + + if (tryStatement.exceptClauses().size() == 1) { + FailCall exceptFail = failCallFromSingleStatementBody(tryStatement.exceptClauses().get(0).body().statements(), ctx); + if (exceptFail != null) { + ctx.addIssue(tryStatement.tryKeyword(), endToken(tryStatement), NO_EXCEPTION_MESSAGE) + .secondary(exceptFail.callExpression(), NO_EXCEPTION_SECONDARY_MESSAGE); + return; + } + } + + FailCall failCall = failCallFromElseClause(tryStatement.elseClause(), ctx); + if (failCall == null) { + failCall = failCallFromTryBody(tryStatement.body().statements(), ctx); + } + if (failCall == null) { + return; + } + + ctx.addIssue(tryStatement.tryKeyword(), endToken(tryStatement), failCall.primaryMessage()) + .secondary(failCall.callExpression(), failCall.secondaryMessage()); + } + + private static Token endToken(TryStatement tryStatement) { + var elseClause = tryStatement.elseClause(); + if (elseClause != null) { + return lastStatement(elseClause.body().statements()).lastToken(); + } + return lastStatement(tryStatement.exceptClauses().get(tryStatement.exceptClauses().size() - 1).body().statements()).lastToken(); + } + + private static Statement lastStatement(List statements) { + return statements.get(statements.size() - 1); + } + + private static boolean hasSupportedExceptClauses(TryStatement tryStatement) { + return !tryStatement.exceptClauses().isEmpty() && tryStatement.exceptClauses().stream().allMatch(exceptClause -> + exceptClause.starToken() == null && exceptClause.exception() != null); + } + + @Nullable + private static FailCall failCallFromElseClause(@Nullable ElseClause elseClause, SubscriptionContext ctx) { + if (elseClause == null) { + return null; + } + return failCallFromSingleStatementBody(elseClause.body().statements(), ctx); + } + + @Nullable + private static FailCall failCallFromTryBody(List statements, SubscriptionContext ctx) { + if (statements.size() < 2) { + return null; + } + return failCallFromStatement(statements.get(statements.size() - 1), ctx); + } + + @Nullable + private static FailCall failCallFromSingleStatementBody(List statements, SubscriptionContext ctx) { + if (statements.size() != 1) { + return null; + } + return failCallFromStatement(statements.get(0), ctx); + } + + @Nullable + private static FailCall failCallFromStatement(Statement statement, SubscriptionContext ctx) { + if (!(statement instanceof ExpressionStatement expressionStatement) || expressionStatement.expressions().size() != 1) { + return null; + } + Expression expression = expressionStatement.expressions().get(0); + if (!(expression instanceof CallExpression callExpression)) { + return null; + } + if (isPytestFail(callExpression, ctx)) { + return new FailCall(callExpression, PYTEST_MESSAGE, DEDICATED_ASSERTION_SECONDARY_MESSAGE); + } + if (isUnittestFail(callExpression, ctx)) { + return new FailCall(callExpression, UNITTEST_MESSAGE, DEDICATED_ASSERTION_SECONDARY_MESSAGE); + } + return null; + } + + private static boolean isPytestFail(CallExpression callExpression, SubscriptionContext ctx) { + return PYTEST_FAIL_MATCHER.isTrueFor(callExpression.callee(), ctx); + } + + private static boolean isUnittestFail(CallExpression callExpression, SubscriptionContext ctx) { + return UNITTEST_FAIL_MATCHER.isTrueFor(callExpression.callee(), ctx); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/DeprecatedYieldFixtureCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/DeprecatedYieldFixtureCheck.java new file mode 100644 index 0000000000..b05fa79a95 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/DeprecatedYieldFixtureCheck.java @@ -0,0 +1,53 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S9076") +public class DeprecatedYieldFixtureCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Replace deprecated pytest.yield_fixture with pytest.fixture."; + + private static final TypeMatcher YIELD_FIXTURE_MATCHER = TypeMatchers.isType("pytest.yield_fixture"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.DECORATOR, ctx -> checkDecorator(ctx, (Decorator) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkDecorator(SubscriptionContext ctx, Decorator decorator) { + Expression expression = decorator.expression(); + Expression matchedExpression = expression.is(Tree.Kind.CALL_EXPR) ? ((CallExpression) expression).callee() : expression; + if (YIELD_FIXTURE_MATCHER.isTrueFor(matchedExpression, ctx)) { + ctx.addIssue(expression, MESSAGE); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/DuplicateParametrizeCasesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/DuplicateParametrizeCasesCheck.java new file mode 100644 index 0000000000..5836dcb8ac --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/DuplicateParametrizeCasesCheck.java @@ -0,0 +1,78 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.ArrayList; +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.UnittestUtils; + +@Rule(key = "S9078") +public class DuplicateParametrizeCasesCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove this duplicate test case."; + private static final String SECONDARY_MESSAGE = "Original."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.DECORATOR, DuplicateParametrizeCasesCheck::checkDecorator); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkDecorator(SubscriptionContext ctx) { + Decorator decorator = (Decorator) ctx.syntaxNode(); + Expression valuesExpression = UnittestUtils.parametrizeArgvaluesExpression(decorator, ctx); + if (valuesExpression == null || !valuesExpression.is(Tree.Kind.LIST_LITERAL, Tree.Kind.TUPLE)) { + return; + } + + raiseOnDuplicates(Expressions.expressionsFromListOrTuple(valuesExpression), ctx); + } + + private static void raiseOnDuplicates(List cases, SubscriptionContext ctx) { + List distinctCases = new ArrayList<>(); + for (Expression testCase : cases) { + Expression original = findEquivalent(distinctCases, testCase); + if (original != null) { + ctx.addIssue(testCase, MESSAGE).secondary(original, SECONDARY_MESSAGE); + } else { + distinctCases.add(testCase); + } + } + } + + private static Expression findEquivalent(List distinctCases, Expression testCase) { + Expression normalizedCase = Expressions.removeParentheses(testCase); + for (Expression distinctCase : distinctCases) { + if (CheckUtils.areEquivalent(Expressions.removeParentheses(distinctCase), normalizedCase)) { + return distinctCase; + } + } + return null; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/EmptyParametrizeValuesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/EmptyParametrizeValuesCheck.java new file mode 100644 index 0000000000..371c9137d0 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/EmptyParametrizeValuesCheck.java @@ -0,0 +1,222 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.HashSet; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.NumericLiteral; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.UnaryExpression; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8998") +public class EmptyParametrizeValuesCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Add at least one case to the parametrize values."; + + private static final TypeMatcher PYTEST_PARAMETRIZE_MATCHER = TypeMatchers.isType("pytest.mark.parametrize"); + private static final TypeMatcher POPULATING_METHOD_MATCHER = TypeMatchers.any( + TypeMatchers.isType("list.append"), + TypeMatchers.isType("list.extend"), + TypeMatchers.isType("list.insert"), + TypeMatchers.isType("dict.update"), + TypeMatchers.isType("dict.setdefault"), + TypeMatchers.isType("set.add"), + TypeMatchers.isType("set.update"), + TypeMatchers.isType("typing.MutableMapping.update"), + TypeMatchers.isType("typing.MutableMapping.setdefault")); + private static final TypeMatcher EMPTY_NO_ARG_CONSTRUCTOR_MATCHER = TypeMatchers.any( + TypeMatchers.isType("list"), + TypeMatchers.isType("dict"), + TypeMatchers.isType("set"), + TypeMatchers.isType("tuple")); + private static final TypeMatcher RANGE_MATCHER = TypeMatchers.isType("range"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.DECORATOR, EmptyParametrizeValuesCheck::checkDecorator); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkDecorator(SubscriptionContext ctx) { + Decorator decorator = (Decorator) ctx.syntaxNode(); + Expression expression = decorator.expression(); + if (!expression.is(Tree.Kind.CALL_EXPR)) { + return; + } + + CallExpression callExpression = (CallExpression) expression; + if (!PYTEST_PARAMETRIZE_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return; + } + + RegularArgument valuesArgument = TreeUtils.nthArgumentOrKeyword(1, "argvalues", callExpression.arguments()); + if (valuesArgument == null) { + return; + } + + Expression valuesExpression = Expressions.removeParentheses(valuesArgument.expression()); + if (isEmptyParametrizeValues(valuesExpression, ctx) && !isCollectionPopulatedBeforeTest(valuesExpression, ctx)) { + ctx.addIssue(valuesExpression, MESSAGE); + } + } + + private static boolean isEmptyParametrizeValues(Expression valuesExpression, SubscriptionContext ctx) { + if (Expressions.isFalsy(valuesExpression) || isEmptyIterableConstructor(valuesExpression, ctx)) { + return true; + } + if (!(valuesExpression instanceof Name name)) { + return false; + } + Expression assigned = Expressions.singleAssignedValue(name); + return assigned != null && isEmptyIterableConstructor(Expressions.removeParentheses(assigned), ctx); + } + + private static boolean isEmptyIterableConstructor(Expression expression, SubscriptionContext ctx) { + if (!(expression instanceof CallExpression callExpression)) { + return false; + } + if (EMPTY_NO_ARG_CONSTRUCTOR_MATCHER.isTrueFor(callExpression.callee(), ctx) && callExpression.arguments().isEmpty()) { + return true; + } + return isEmptyRange(callExpression, ctx); + } + + private static boolean isEmptyRange(CallExpression callExpression, SubscriptionContext ctx) { + if (!RANGE_MATCHER.isTrueFor(callExpression.callee(), ctx) || callExpression.arguments().size() != 1) { + return false; + } + Argument argument = callExpression.arguments().get(0); + if (!(argument instanceof RegularArgument regularArgument)) { + return false; + } + Long bound = numericLiteralValue(Expressions.removeParentheses(regularArgument.expression())); + return bound != null && bound <= 0L; + } + + private static Long numericLiteralValue(Expression expression) { + if (expression instanceof NumericLiteral numericLiteral) { + try { + return numericLiteral.valueAsLong(); + } catch (NumberFormatException e) { + return null; + } + } + if (expression instanceof UnaryExpression unaryExpression && "-".equals(unaryExpression.operator().value())) { + Long positive = numericLiteralValue(Expressions.removeParentheses(unaryExpression.expression())); + return positive == null ? null : -positive; + } + return null; + } + + /** + * Collections that start empty but are filled before tests run are not empty at runtime, + * even when the mutation appears after the parametrize decorator in source order. + * Only mutations that execute at import / class-definition time are considered. + */ + private static boolean isCollectionPopulatedBeforeTest(Expression valuesExpression, SubscriptionContext ctx) { + if (!(valuesExpression instanceof Name name)) { + return false; + } + SymbolV2 symbol = name.symbolV2(); + if (symbol == null) { + return false; + } + for (SymbolV2 relatedSymbol : symbolsIncludingSimpleAliases(symbol)) { + for (UsageV2 usage : relatedSymbol.usages()) { + Tree usageTree = usage.tree(); + if (isExecutedBeforeCollection(usageTree) && isPopulatingMethodCallOnReceiver(usageTree, ctx)) { + return true; + } + } + } + return false; + } + + private static Set symbolsIncludingSimpleAliases(SymbolV2 symbol) { + Set symbols = new HashSet<>(); + symbols.add(symbol); + for (UsageV2 usage : symbol.usages()) { + symbols.addAll(collectSimpleAliasSymbols(usage.tree())); + } + return symbols; + } + + private static Set collectSimpleAliasSymbols(Tree usageTree) { + if (!(usageTree instanceof Name)) { + return Set.of(); + } + Tree assignmentTree = TreeUtils.firstAncestorOfKind(usageTree, Tree.Kind.ASSIGNMENT_STMT); + if (!(assignmentTree instanceof AssignmentStatement assignment)) { + return Set.of(); + } + if (Expressions.removeParentheses(assignment.assignedValue()) != usageTree) { + return Set.of(); + } + Set aliases = new HashSet<>(); + for (ExpressionList lhsList : assignment.lhsExpressions()) { + if (lhsList.expressions().size() != 1) { + continue; + } + Expression lhs = lhsList.expressions().get(0); + if (lhs instanceof Name lhsName && lhsName.symbolV2() != null) { + aliases.add(lhsName.symbolV2()); + } + } + return aliases; + } + + /** + * Pytest collects parametrize values at import time. Mutations nested inside functions + * (which are not executed during collection) must not suppress the issue. + */ + private static boolean isExecutedBeforeCollection(Tree tree) { + return TreeUtils.firstAncestorOfKind(tree, Tree.Kind.FUNCDEF) == null; + } + + private static boolean isPopulatingMethodCallOnReceiver(Tree usageTree, SubscriptionContext ctx) { + Tree parent = usageTree.parent(); + if (!(parent instanceof QualifiedExpression qualifiedExpression) || qualifiedExpression.qualifier() != usageTree) { + return false; + } + if (!(qualifiedExpression.parent() instanceof CallExpression callExpression)) { + return false; + } + return POPULATING_METHOD_MATCHER.isTrueFor(callExpression.callee(), ctx); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/FixtureParamDependenciesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/FixtureParamDependenciesCheck.java new file mode 100644 index 0000000000..6c355ab63f --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/FixtureParamDependenciesCheck.java @@ -0,0 +1,138 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringElement; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.UnittestUtils; +import org.sonar.python.semantic.v2.typeshed.TypeShedConstants; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8993") +public class FixtureParamDependenciesCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Declare this fixture as a test function parameter instead of using \"request.getfixturevalue()\" with a string literal."; + private static final String CONFTEST_FILE_NAME = "conftest.py"; + private static final String PYTEST_HOOK_PREFIX = "pytest_"; + private static final TypeMatcher GET_FIXTURE_VALUE_MATCHER = TypeMatchers.isType( + TypeShedConstants.PYTEST_FIXTURE_REQUEST_GET_FIXTURE_VALUE_FQN + ); + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN(UnittestUtils.PYTEST_FIXTURE_DECORATOR_FQN); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, FixtureParamDependenciesCheck::checkCallExpression); + } + + private static void checkCallExpression(SubscriptionContext ctx) { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + if (!GET_FIXTURE_VALUE_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return; + } + + FunctionDef enclosingFunction = (FunctionDef) TreeUtils.firstAncestorOfKind(callExpression, Tree.Kind.FUNCDEF); + if (enclosingFunction == null || !isCollectedTestFunction(ctx, enclosingFunction)) { + return; + } + + Expression fixtureNameExpression = fixtureNameArgument(callExpression); + if (fixtureNameExpression == null || !isStaticFixtureName(fixtureNameExpression)) { + return; + } + + ctx.addIssue(fixtureNameExpression, MESSAGE); + } + + /** + * True only for plain string literals, useless f-strings (no replacement fields), or names that + * resolve to such a constant. Interpolated f-strings and other dynamic expressions are ignored. + */ + private static boolean isStaticFixtureName(Expression expression) { + Expression unwrapped = Expressions.removeParentheses(expression); + if (unwrapped instanceof Name name) { + Expression assignedValue = Expressions.singleAssignedValue(name); + return assignedValue != null && isStaticFixtureName(assignedValue); + } + if (!(unwrapped instanceof StringLiteral stringLiteral)) { + return false; + } + return stringLiteral.stringElements().stream().noneMatch(FixtureParamDependenciesCheck::isDynamicallyInterpolated); + } + + private static boolean isDynamicallyInterpolated(StringElement stringElement) { + return stringElement.isInterpolated() && !stringElement.formattedExpressions().isEmpty(); + } + + private static boolean isCollectedTestFunction(SubscriptionContext ctx, FunctionDef functionDef) { + if (isPytestFixture(functionDef, ctx)) { + return false; + } + if (isPytestHook(functionDef)) { + return false; + } + if (isConftestFile(ctx.pythonFile().fileName())) { + return false; + } + return UnittestUtils.isPytestStyleTestFunction(functionDef, ctx.pythonFile().fileName()); + } + + private static boolean isPytestFixture(FunctionDef functionDef, SubscriptionContext ctx) { + return functionDef.decorators().stream() + .anyMatch(decorator -> PYTEST_FIXTURE_MATCHER.isTrueFor(getDecoratorFunctionExpression(decorator), ctx)); + } + + private static boolean isPytestHook(FunctionDef functionDef) { + return functionDef.name().name().startsWith(PYTEST_HOOK_PREFIX); + } + + private static boolean isConftestFile(String fileName) { + return CONFTEST_FILE_NAME.equals(fileName); + } + + private static Expression getDecoratorFunctionExpression(Decorator decorator) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + return callExpression.callee(); + } + return expression; + } + + @Nullable + private static Expression fixtureNameArgument(CallExpression callExpression) { + RegularArgument argument = TreeUtils.nthArgumentOrKeyword(0, "argname", callExpression.arguments()); + return argument == null ? null : argument.expression(); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/GroupSimilarTestsParameterizedCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/GroupSimilarTestsParameterizedCheck.java new file mode 100644 index 0000000000..e7e4926d2b --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/GroupSimilarTestsParameterizedCheck.java @@ -0,0 +1,215 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FileInput; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.RaiseStatement; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.StatementList; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.Tree.Kind; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.UnittestUtils; +import org.sonar.python.tree.TreeUtils; + +import javax.annotation.Nullable; + +@Rule(key = "S5976") +public class GroupSimilarTestsParameterizedCheck extends PythonSubscriptionCheck { + private static final String MESSAGE = "Group these similar tests into a single parameterized test."; + private static final int MIN_GROUP_SIZE = 3; + private static final int MAX_PARAMETER_COUNT = 3; + private static final TypeMatcher NOT_IMPLEMENTED_ERROR_MATCHER = TypeMatchers.any( + TypeMatchers.isType("builtins.NotImplementedError"), + TypeMatchers.isObjectInstanceOf("builtins.NotImplementedError")); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> checkFileInput(ctx, (FileInput) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkFileInput(SubscriptionContext ctx, FileInput fileInput) { + var statements = fileInput.statements(); + if (statements == null) { + return; + } + checkStatementListRecursively(ctx, statements); + } + + private static void checkStatementListRecursively(SubscriptionContext ctx, StatementList statementList) { + checkStatementList(ctx, statementList); + for (Statement statement : statementList.statements()) { + if (statement instanceof ClassDef classDef) { + checkStatementListRecursively(ctx, classDef.body()); + } + } + } + + private static void checkStatementList(SubscriptionContext ctx, StatementList statementList) { + List testFunctions = statementList.statements().stream() + .filter(FunctionDef.class::isInstance) + .map(FunctionDef.class::cast) + .filter(functionDef -> isCandidateTestFunction(ctx, functionDef)) + .toList(); + + Set alreadyReported = new HashSet<>(); + for (int i = 0; i < testFunctions.size(); i++) { + FunctionDef anchor = testFunctions.get(i); + if (alreadyReported.contains(anchor)) { + continue; + } + + List similarFunctions = new ArrayList<>(); + similarFunctions.add(anchor); + for (int j = i + 1; j < testFunctions.size(); j++) { + FunctionDef candidate = testFunctions.get(j); + if (areSimilarTests(anchor, candidate)) { + similarFunctions.add(candidate); + } + } + + if (similarFunctions.size() >= MIN_GROUP_SIZE) { + var issue = ctx.addIssue(anchor.name(), MESSAGE); + similarFunctions.stream().skip(1).forEach(similarFunction -> issue.secondary(similarFunction.name(), "Similar test.")); + alreadyReported.addAll(similarFunctions); + } + } + } + + private static boolean isCandidateTestFunction(SubscriptionContext ctx, FunctionDef functionDef) { + return UnittestUtils.isTestMethodName(functionDef.name().name()) + && functionDef.decorators().isEmpty() + && !isPlaceholderTest(functionDef, ctx) + && (UnittestUtils.isPytestStyleTestFunction(functionDef, ctx.pythonFile().fileName()) || UnittestUtils.isWithinUnittestTestCase(functionDef)); + } + + private static boolean isPlaceholderTest(FunctionDef functionDef, SubscriptionContext ctx) { + List statements = functionDef.body().statements(); + if (statements.size() != 1) { + return false; + } + Statement statement = statements.get(0); + return statement.is(Kind.PASS_STMT) || isNotImplementedErrorRaise(statement, ctx); + } + + private static boolean isNotImplementedErrorRaise(Statement statement, SubscriptionContext ctx) { + if (!(statement instanceof RaiseStatement raiseStatement) || raiseStatement.expressions().size() != 1) { + return false; + } + return isNotImplementedError(raiseStatement.expressions().get(0), ctx); + } + + private static boolean isNotImplementedError(Expression expression, SubscriptionContext ctx) { + return NOT_IMPLEMENTED_ERROR_MATCHER.isTrueFor(expression, ctx); + } + + private static boolean areSimilarTests(FunctionDef left, FunctionDef right) { + if (!sameNamePattern(left, right)) { + return false; + } + if (!sameTestKind(left, right)) { + return false; + } + if (!CheckUtils.areEquivalent(left.parameters(), right.parameters())) { + return false; + } + var differences = new DifferenceCounter(); + return differences.areSimilar(left.body(), right.body()); + } + + private static boolean sameTestKind(FunctionDef left, FunctionDef right) { + boolean leftUnittest = UnittestUtils.isWithinUnittestTestCase(left); + return leftUnittest == UnittestUtils.isWithinUnittestTestCase(right); + } + + private static boolean sameNamePattern(FunctionDef left, FunctionDef right) { + return normalizeName(left).equals(normalizeName(right)); + } + + private static String normalizeName(FunctionDef functionDef) { + String name = functionDef.name().name(); + int suffixStart = name.length(); + while (suffixStart > 0 && Character.isDigit(name.charAt(suffixStart - 1))) { + suffixStart--; + } + return name.substring(0, suffixStart); + } + + private static class DifferenceCounter { + private final Set differences = new HashSet<>(); + + private boolean areSimilar(@Nullable Tree left, @Nullable Tree right) { + if (left == right) { + return true; + } + if (left == null || right == null) { + return false; + } + if (left.getKind() != right.getKind() || left.children().size() != right.children().size()) { + return false; + } + if (left.children().isEmpty() && right.children().isEmpty()) { + return compareLeaves(left, right); + } + for (int i = 0; i < left.children().size(); i++) { + if (!areSimilar(left.children().get(i), right.children().get(i))) { + return false; + } + } + return true; + } + + private boolean compareLeaves(Tree left, Tree right) { + String leftValue = left.firstToken() == null ? null : left.firstToken().value(); + String rightValue = right.firstToken() == null ? null : right.firstToken().value(); + if ((leftValue == null && rightValue == null) || (leftValue != null && leftValue.equals(rightValue))) { + return true; + } + if (!isParameterizableLiteral(left) || !isParameterizableLiteral(right)) { + return false; + } + differences.add(new LiteralDifference(left.getKind(), leftValue, rightValue)); + return differences.size() <= MAX_PARAMETER_COUNT; + } + + private static boolean isParameterizableLiteral(Tree tree) { + Tree candidate = tree.parent() != null ? tree.parent() : tree; + return candidate.is(Kind.NUMERIC_LITERAL, Kind.STRING_LITERAL, Kind.STRING_ELEMENT, Kind.NONE) + || TreeUtils.isBooleanLiteral(candidate); + } + + private record LiteralDifference(Kind kind, @Nullable String leftValue, @Nullable String rightValue) { + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/IdenticalAssertionArgumentsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/IdenticalAssertionArgumentsCheck.java new file mode 100644 index 0000000000..9b3d4ae116 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/IdenticalAssertionArgumentsCheck.java @@ -0,0 +1,97 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AssertStatement; +import org.sonar.plugins.python.api.tree.BinaryExpression; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.UnittestUtils; +import org.sonar.python.checks.utils.UnittestUtils.AssertionArguments; +import org.sonar.python.checks.utils.UnittestUtils.AssertionFrameworkHandlers; + +import static org.sonar.python.checks.utils.UnittestUtils.ASSERTPY_EQUALITY_ASSERTION_MATCHER; + +@Rule(key = "S5863") +public class IdenticalAssertionArgumentsCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Replace this assertion to not have the same actual and expected expression."; + private static final String SECONDARY_ACTUAL_MESSAGE = "This is the same expression as the expected argument."; + private static final String SECONDARY_ASSIGNMENT_MESSAGE = "Assigned here."; + private static final Set PYTEST_OPERATORS = Set.of("==", "!="); + + @Override + public void initialize(Context context) { + UnittestUtils.registerAssertionSyntaxNodeConsumers(context, new AssertionFrameworkHandlers( + IdenticalAssertionArgumentsCheck::checkUnittestAssertion, + IdenticalAssertionArgumentsCheck::checkAssertpyAssertion, + IdenticalAssertionArgumentsCheck::checkPytestAssertion)); + } + + @Override + public CheckScope scope() { + return CheckScope.TESTS; + } + + private static void checkUnittestAssertion(SubscriptionContext ctx, CallExpression callExpression) { + AssertionArguments arguments = UnittestUtils.unittestAssertionArguments(callExpression, ctx); + if (arguments != null) { + reportIfIdenticalArguments(ctx, arguments); + } + } + + private static void checkPytestAssertion(SubscriptionContext ctx, AssertStatement assertStatement) { + if (!UnittestUtils.isPytestStyleTestFunction(ctx, assertStatement)) { + return; + } + + Expression condition = Expressions.removeParentheses(assertStatement.condition()); + if (!(condition instanceof BinaryExpression binaryExpression) + || !PYTEST_OPERATORS.contains(binaryExpression.operator().value())) { + return; + } + + reportIfIdenticalArguments(ctx, new AssertionArguments(binaryExpression.leftOperand(), binaryExpression.rightOperand())); + } + + private static void checkAssertpyAssertion(SubscriptionContext ctx, CallExpression callExpression) { + AssertionArguments arguments = UnittestUtils.assertpyAssertionArguments(callExpression, ctx, ASSERTPY_EQUALITY_ASSERTION_MATCHER); + if (arguments != null) { + reportIfIdenticalArguments(ctx, arguments); + } + } + + private static void reportIfIdenticalArguments(SubscriptionContext ctx, AssertionArguments arguments) { + if (CheckUtils.areEquivalent(arguments.actual(), arguments.expected())) { + var issue = ctx.addIssue(arguments.expected(), MESSAGE) + .secondary(arguments.actual(), SECONDARY_ACTUAL_MESSAGE); + if (arguments.actual() instanceof Name name) { + Expression assignment = Expressions.singleAssignedValue(name); + if (assignment != null) { + issue.secondary(assignment, SECONDARY_ASSIGNMENT_MESSAGE); + } + } + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/ImplicitlySkippedTestCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/ImplicitlySkippedTestCheck.java index b0ad28040a..1b2298a3d8 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/tests/ImplicitlySkippedTestCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/ImplicitlySkippedTestCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -35,7 +35,7 @@ import org.sonar.plugins.python.api.tree.ReturnStatement; import org.sonar.plugins.python.api.tree.Statement; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.tests.UnittestUtils; +import org.sonar.python.checks.utils.UnittestUtils; @Rule(key = "S5918") public class ImplicitlySkippedTestCheck extends PythonSubscriptionCheck { diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/IntentionalTestFailureMessageCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/IntentionalTestFailureMessageCheck.java new file mode 100644 index 0000000000..83faaac7fb --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/IntentionalTestFailureMessageCheck.java @@ -0,0 +1,163 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AliasedName; +import org.sonar.plugins.python.api.tree.AssertStatement; +import org.sonar.plugins.python.api.tree.BaseTreeVisitor; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.DottedName; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FileInput; +import org.sonar.plugins.python.api.tree.ImportFrom; +import org.sonar.plugins.python.api.tree.ImportName; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.NumericLiteral; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S9077") +public class IntentionalTestFailureMessageCheck extends PythonSubscriptionCheck { + + private static final String ASSERT_MESSAGE = "Replace this assertion with pytest.fail(...) and provide a message."; + private static final String FAIL_MESSAGE = "Add a message explaining why this test fails."; + + private static final TypeMatcher PYTEST_FAIL_MATCHER = TypeMatchers.isType("pytest.fail"); + + private boolean pytestImported; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> pytestImported = importsPytest((FileInput) ctx.syntaxNode())); + context.registerSyntaxNodeConsumer(Tree.Kind.ASSERT_STMT, ctx -> checkAssertStatement(ctx, (AssertStatement) ctx.syntaxNode())); + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> checkCallExpression(ctx, (CallExpression) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private void checkAssertStatement(SubscriptionContext ctx, AssertStatement assertStatement) { + // Without a pytest import we cannot know whether the runner is pytest or unittest; + // skip assert False / assert 0 to avoid FPs when pytest.fail is unavailable. + if (!pytestImported) { + return; + } + Expression condition = Expressions.removeParentheses(assertStatement.condition()); + if (isFalseOrZeroLiteral(condition)) { + ctx.addIssue(assertStatement, ASSERT_MESSAGE); + } + } + + private static boolean isFalseOrZeroLiteral(Expression expression) { + if (expression.is(Tree.Kind.NAME)) { + return "False".equals(((Name) expression).name()); + } + if (expression.is(Tree.Kind.NUMERIC_LITERAL)) { + try { + return ((NumericLiteral) expression).valueAsLong() == 0; + } catch (NumberFormatException nfe) { + return false; + } + } + return false; + } + + private static void checkCallExpression(SubscriptionContext ctx, CallExpression callExpression) { + if (!PYTEST_FAIL_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return; + } + + RegularArgument messageArgument = messageArgument(callExpression); + if (hasNoMessage(messageArgument)) { + ctx.addIssue(callExpression, FAIL_MESSAGE); + } + } + + /** + * Resolves the failure message argument. Prefer {@code reason=} or a positional argument, + * and also accept the legacy {@code msg=} keyword used by older pytest versions. + */ + @Nullable + private static RegularArgument messageArgument(CallExpression callExpression) { + RegularArgument reasonOrPositional = TreeUtils.nthArgumentOrKeyword(0, "reason", callExpression.arguments()); + if (reasonOrPositional != null) { + return reasonOrPositional; + } + return TreeUtils.argumentByKeyword("msg", callExpression.arguments()); + } + + private static boolean hasNoMessage(@Nullable RegularArgument reasonArgument) { + if (reasonArgument == null) { + return true; + } + Expression reasonExpression = reasonArgument.expression(); + return reasonExpression.is(Tree.Kind.STRING_LITERAL) && ((StringLiteral) reasonExpression).trimmedQuotesValue().trim().isEmpty(); + } + + private static boolean importsPytest(FileInput fileInput) { + PytestImportVisitor visitor = new PytestImportVisitor(); + fileInput.accept(visitor); + return visitor.found; + } + + private static final class PytestImportVisitor extends BaseTreeVisitor { + private boolean found; + + @Override + public void visitImportName(ImportName importName) { + if (found) { + return; + } + for (AliasedName module : importName.modules()) { + if (isPytestModule(module.dottedName())) { + found = true; + return; + } + } + } + + @Override + public void visitImportFrom(ImportFrom importFrom) { + if (found) { + return; + } + if (isPytestModule(importFrom.module())) { + found = true; + } + } + + private static boolean isPytestModule(@Nullable DottedName dottedName) { + if (dottedName == null) { + return false; + } + List names = dottedName.names(); + return !names.isEmpty() && "pytest".equals(names.get(0).name()); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/MisspelledMockAssertionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/MisspelledMockAssertionCheck.java new file mode 100644 index 0000000000..b063f99382 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/MisspelledMockAssertionCheck.java @@ -0,0 +1,163 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.Set; +import javax.annotation.CheckForNull; +import org.apache.commons.text.similarity.LevenshteinDistance; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.quickfix.TextEditUtils; + +@Rule(key = "S9136") +public class MisspelledMockAssertionCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Correct this misspelled mock assertion; did you mean \"%s\"?"; + private static final String QUICK_FIX_MESSAGE = "Replace with \"%s\""; + + /** + * Only raise when the accessed name is a near-miss of a real mock assertion API. + * Distance 2 still requires a unique best match, which keeps the rule conservative. + */ + private static final int MAX_EDIT_DISTANCE = 2; + private static final LevenshteinDistance LEVENSHTEIN = new LevenshteinDistance(MAX_EDIT_DISTANCE); + + private static final Set KNOWN_ASSERTION_METHODS = Set.of( + "assert_called", + "assert_called_once", + "assert_called_with", + "assert_called_once_with", + "assert_any_call", + "assert_has_calls", + "assert_not_called", + "assert_awaited", + "assert_awaited_once", + "assert_awaited_with", + "assert_awaited_once_with", + "assert_any_await", + "assert_has_awaits", + "assert_not_awaited"); + + private static final TypeMatcher MOCK_INSTANCE = TypeMatchers.any( + TypeMatchers.isObjectInstanceOf("unittest.mock.NonCallableMock"), + TypeMatchers.isObjectInstanceOf("mock.mock.NonCallableMock")); + + private static final TypeMatcher ASYNC_MOCK_INSTANCE = TypeMatchers.any( + TypeMatchers.isObjectInstanceOf("unittest.mock.AsyncMock"), + TypeMatchers.isObjectInstanceOf("mock.mock.AsyncMock")); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, MisspelledMockAssertionCheck::checkCall); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkCall(SubscriptionContext ctx) { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + Expression callee = Expressions.removeParentheses(callExpression.callee()); + if (!(callee instanceof QualifiedExpression qualifiedExpression)) { + return; + } + + Name memberName = qualifiedExpression.name(); + String name = memberName.name(); + if (KNOWN_ASSERTION_METHODS.contains(name) || !name.startsWith("assert")) { + return; + } + + Expression qualifier = Expressions.removeParentheses(qualifiedExpression.qualifier()); + if (!isMockOrChildMock(qualifier, ctx)) { + return; + } + // Exact declared members are not typos (e.g. a real assert_* helper on the mock type). + if (TypeMatchers.hasMember(name).isTrueFor(qualifier, ctx)) { + return; + } + + String suggestion = findUniqueCloseMatch(name, isAsyncMockOrChildMock(qualifier, ctx)); + if (suggestion == null) { + return; + } + + var issue = ctx.addIssue(memberName, String.format(MESSAGE, suggestion)); + issue.addQuickFix(PythonQuickFix.newQuickFix(String.format(QUICK_FIX_MESSAGE, suggestion)) + .addTextEdit(TextEditUtils.replace(memberName, suggestion)) + .build()); + } + + private static boolean isMockOrChildMock(Expression expression, SubscriptionContext ctx) { + return matchesAlongQualifierChain(expression, ctx, MOCK_INSTANCE); + } + + private static boolean isAsyncMockOrChildMock(Expression expression, SubscriptionContext ctx) { + return matchesAlongQualifierChain(expression, ctx, ASYNC_MOCK_INSTANCE); + } + + private static boolean matchesAlongQualifierChain(Expression expression, SubscriptionContext ctx, TypeMatcher matcher) { + Expression current = Expressions.removeParentheses(expression); + while (true) { + if (matcher.isTrueFor(current, ctx)) { + return true; + } + if (!(current instanceof QualifiedExpression qualifiedExpression)) { + return false; + } + current = Expressions.removeParentheses(qualifiedExpression.qualifier()); + } + } + + @CheckForNull + private static String findUniqueCloseMatch(String name, boolean asyncMock) { + String bestMatch = null; + int bestDistance = MAX_EDIT_DISTANCE + 1; + boolean tied = false; + for (String known : KNOWN_ASSERTION_METHODS) { + if (isAwaitAssertion(known) && !asyncMock) { + continue; + } + int distance = LEVENSHTEIN.apply(name, known); + if (distance > 0) { + if (distance < bestDistance) { + bestDistance = distance; + bestMatch = known; + tied = false; + } else if (distance == bestDistance) { + tied = true; + } + } + } + return tied ? null : bestMatch; + } + + private static boolean isAwaitAssertion(String methodName) { + return methodName.contains("await"); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/MockPatchLambdaReturnValueCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/MockPatchLambdaReturnValueCheck.java new file mode 100644 index 0000000000..40490de108 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/MockPatchLambdaReturnValueCheck.java @@ -0,0 +1,150 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import java.util.function.Predicate; +import java.util.stream.Stream; +import javax.annotation.CheckForNull; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.LambdaExpression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.ParameterList; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.MockPatchUtils; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S9081") +public class MockPatchLambdaReturnValueCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Replace this lambda with a \"return_value\" argument."; + private static final String QUICK_FIX_MESSAGE = "Replace this lambda with a \"return_value\" argument"; + + private static final String NEW_KEYWORD = "new"; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, MockPatchLambdaReturnValueCheck::checkCall); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkCall(SubscriptionContext ctx) { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + List arguments = callExpression.arguments(); + if (Expressions.containsSpreadOperator(arguments)) { + return; + } + + int newPosition = MockPatchUtils.newArgumentPosition(callExpression.callee(), ctx); + if (newPosition < 0) { + return; + } + + RegularArgument newArgument = TreeUtils.nthArgumentOrKeyword(newPosition, NEW_KEYWORD, arguments); + if (newArgument == null || !(Expressions.removeParentheses(newArgument.expression()) instanceof LambdaExpression lambda) + || usesItsParameters(lambda)) { + return; + } + // Decorators evaluate return_value= at definition time; skip lambdas whose body calls something, + // since that may intentionally re-evaluate on each invocation. Non-decorator patches keep the issue. + if (TreeUtils.firstAncestorOfKind(callExpression, Tree.Kind.DECORATOR) != null + && containsCallExpression(lambda.expression())) { + return; + } + + var issue = ctx.addIssue(lambda, MESSAGE); + String replacement = returnValueReplacement(callExpression, lambda, newArgument, arguments); + if (replacement != null) { + issue.addQuickFix(PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.replace(newArgument, replacement)) + .build()); + } + } + + @CheckForNull + private static String returnValueReplacement(CallExpression callExpression, LambdaExpression lambda, RegularArgument newArgument, + List arguments) { + if (TreeUtils.firstAncestorOfKind(callExpression, Tree.Kind.DECORATOR) != null) { + // Without "new", the patching call injects a mock into the decorated function, which then needs an extra parameter. + return null; + } + // return_value= evaluates the expression once at patch construction; a call in the lambda body would be re-run per + // invocation, so rewriting would change behavior for both decorator and with-block forms. + if (containsCallExpression(lambda.expression())) { + return null; + } + if (newArgument.keywordArgument() == null && hasPositionalArgumentAfter(newArgument, arguments)) { + // Turning the positional argument into a keyword one would leave positional arguments after a keyword argument. + return null; + } + String returnedValue = TreeUtils.treeToString(lambda.expression(), false); + if (returnedValue == null) { + return null; + } + return "return_value=" + returnedValue; + } + + private static boolean hasPositionalArgumentAfter(RegularArgument newArgument, List arguments) { + // Unpacked arguments have already been excluded, hence every argument is a regular one. + return arguments.stream() + .dropWhile(argument -> argument != newArgument) + .skip(1) + .map(RegularArgument.class::cast) + .anyMatch(argument -> argument.keywordArgument() == null); + } + + private static boolean usesItsParameters(LambdaExpression lambda) { + ParameterList parameterList = lambda.parameters(); + if (parameterList == null) { + return false; + } + Predicate isParameterUsage = tree -> tree instanceof Name name && isDeclaredIn(name.symbolV2(), parameterList); + Expression body = lambda.expression(); + return isParameterUsage.test(body) || TreeUtils.hasDescendant(body, isParameterUsage); + } + + private static boolean containsCallExpression(Expression expression) { + return expression instanceof CallExpression + || TreeUtils.hasDescendant(expression, CallExpression.class::isInstance); + } + + /** + * Names bound by an enclosing scope are also parameters, hence the check that the declaration belongs to the given parameter list. + */ + private static boolean isDeclaredIn(@Nullable SymbolV2 symbol, ParameterList parameterList) { + return Stream.ofNullable(symbol) + .flatMap(s -> s.usages().stream()) + .filter(usage -> usage.kind() == UsageV2.Kind.PARAMETER) + .anyMatch(usage -> TreeUtils.firstAncestor(usage.tree(), parameterList::equals) != null); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/MocksShouldUseAutospecCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/MocksShouldUseAutospecCheck.java new file mode 100644 index 0000000000..87639b1dda --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/MocksShouldUseAutospecCheck.java @@ -0,0 +1,346 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.Set; +import javax.annotation.CheckForNull; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Parameter; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.WithItem; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.MockPatchUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S9137") +public class MocksShouldUseAutospecCheck extends PythonSubscriptionCheck { + + private static final String MOCK_MESSAGE_FORMAT = + "Replace this \"%s()\" with \"create_autospec()\", or pass \"spec=\" / \"spec_set=\"."; + private static final String PATCH_MESSAGE = + "Add \"autospec=True\" to this patch call, or pass an explicit \"spec=\" / \"spec_set=\"."; + private static final String AUTOSPEC_FALSE_MESSAGE = + "Replace \"autospec=False\" with \"autospec=True\", or pass an explicit \"spec=\" / \"spec_set=\"."; + + private static final String SPEC = "spec"; + private static final String SPEC_SET = "spec_set"; + private static final String AUTOSPEC = "autospec"; + private static final String NEW = "new"; + private static final String NEW_CALLABLE = "new_callable"; + private static final String SELF = "self"; + private static final String CLS = "cls"; + + /** + * unittest.mock helpers / assertions — invoking these does not mean the test exercises a collaborator API + * that would benefit from autospeccing. + */ + private static final Set MOCK_HELPER_METHODS = Set.of( + "assert_called", + "assert_called_once", + "assert_called_with", + "assert_called_once_with", + "assert_any_call", + "assert_has_calls", + "assert_not_called", + "assert_never_called", + "reset_mock", + "attach_mock", + "configure_mock"); + + private static final TypeMatcher MOCK_CLASS_MATCHER = TypeMatchers.any( + TypeMatchers.isType("unittest.mock.Mock"), + TypeMatchers.isType("unittest.mock.MagicMock"), + TypeMatchers.isType("mock.mock.Mock"), + TypeMatchers.isType("mock.mock.MagicMock")); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, MocksShouldUseAutospecCheck::checkCall); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkCall(SubscriptionContext ctx) { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + List arguments = callExpression.arguments(); + if (Expressions.containsSpreadOperator(arguments)) { + return; + } + + Expression callee = Expressions.removeParentheses(callExpression.callee()); + if (MOCK_CLASS_MATCHER.isTrueFor(callee, ctx)) { + if (!hasMockSpec(arguments) && mockBenefitsFromAutospec(callExpression, ctx)) { + ctx.addIssue(callee, mockMessage(callee)); + } + return; + } + + int newPosition = MockPatchUtils.newArgumentPosition(callee, ctx); + if (newPosition < 0) { + return; + } + if (hasReplacement(arguments, newPosition) || hasPatchSpecOrAutospec(arguments, newPosition)) { + return; + } + if (!patchMockIsUsedInTest(callExpression, ctx)) { + return; + } + ctx.addIssue(callee, patchMessage(arguments, newPosition)); + } + + private static String mockMessage(Expression callee) { + return String.format(MOCK_MESSAGE_FORMAT, mockConstructorName(callee)); + } + + private static String mockConstructorName(Expression callee) { + if (callee instanceof Name name) { + return name.name(); + } + if (callee instanceof QualifiedExpression qualifiedExpression) { + return qualifiedExpression.name().name(); + } + return "Mock"; + } + + private static String patchMessage(List arguments, int newPosition) { + int autospecPosition = newPosition + 4; + RegularArgument autospecArgument = TreeUtils.nthArgumentOrKeyword(autospecPosition, AUTOSPEC, arguments); + if (autospecArgument != null && Expressions.isFalsy(autospecArgument.expression())) { + return AUTOSPEC_FALSE_MESSAGE; + } + return PATCH_MESSAGE; + } + + private static boolean hasReplacement(List arguments, int newPosition) { + return TreeUtils.nthArgumentOrKeyword(newPosition, NEW, arguments) != null + || TreeUtils.argumentByKeyword(NEW_CALLABLE, arguments) != null; + } + + private static boolean hasMockSpec(List arguments) { + // Mock(spec, wraps, name, spec_set, ...) + return TreeUtils.nthArgumentOrKeyword(0, SPEC, arguments) != null + || TreeUtils.nthArgumentOrKeyword(3, SPEC_SET, arguments) != null; + } + + private static boolean hasPatchSpecOrAutospec(List arguments, int newPosition) { + // patch(target, new, spec, create, spec_set, autospec, new_callable) + // patch.object(target, attribute, new, spec, create, spec_set, autospec, new_callable) + int specPosition = newPosition + 1; + int specSetPosition = newPosition + 3; + int autospecPosition = newPosition + 4; + return TreeUtils.nthArgumentOrKeyword(specPosition, SPEC, arguments) != null + || TreeUtils.nthArgumentOrKeyword(specSetPosition, SPEC_SET, arguments) != null + || hasTruthyAutospec(arguments, autospecPosition); + } + + private static boolean hasTruthyAutospec(List arguments, int autospecPosition) { + RegularArgument autospecArgument = TreeUtils.nthArgumentOrKeyword(autospecPosition, AUTOSPEC, arguments); + return autospecArgument != null && !Expressions.isFalsy(autospecArgument.expression()); + } + + /** + * Raise only when the mock is used as a collaborator in the test (passed into a non-mock call, or a + * non-helper method is invoked on it). Field-only stubs cannot be autospecced reliably. + */ + private static boolean mockBenefitsFromAutospec(CallExpression mockConstruction, SubscriptionContext ctx) { + List boundNames = simpleNameBindings(mockConstruction); + if (boundNames.isEmpty()) { + // Attribute assignment (`obj.field = Mock()`) or a discarded call: no collaborator API to mirror. + return isArgumentToNonMockCall(mockConstruction, ctx); + } + for (Name boundName : boundNames) { + SymbolV2 symbol = boundName.symbolV2(); + if (symbol != null && symbol.usages().stream() + .filter(usage -> !usage.isBindingUsage()) + .anyMatch(usage -> isCollaboratorUsage(usage.tree(), ctx))) { + return true; + } + } + return false; + } + + /** + * Simple name bindings only. Attribute / subscription LHS is field stubbing. + * Supports plain, chained (`a = m = Mock()`), and annotated (`name: T = Mock()`) assignments. + */ + private static List simpleNameBindings(CallExpression mockConstruction) { + AssignmentStatement assignment = (AssignmentStatement) TreeUtils.firstAncestorOfKind(mockConstruction, Tree.Kind.ASSIGNMENT_STMT); + if (assignment != null && Expressions.removeParentheses(assignment.assignedValue()) == mockConstruction) { + List names = new ArrayList<>(); + for (ExpressionList target : assignment.lhsExpressions()) { + List exprs = target.expressions(); + // Skip tuple unpacking (`a, b = Mock()`): only single-name targets are true bindings. + if (exprs.size() != 1 || !(exprs.get(0) instanceof Name name)) { + return List.of(); + } + names.add(name); + } + return names; + } + AnnotatedAssignment annotated = (AnnotatedAssignment) TreeUtils.firstAncestorOfKind(mockConstruction, Tree.Kind.ANNOTATED_ASSIGNMENT); + if (annotated != null) { + Expression assignedValue = annotated.assignedValue(); + if (assignedValue != null + && Expressions.removeParentheses(assignedValue) == mockConstruction + && annotated.variable() instanceof Name name) { + return List.of(name); + } + } + return List.of(); + } + + private static boolean isCollaboratorUsage(Tree usageTree, SubscriptionContext ctx) { + Name name = (Name) usageTree; + return isArgumentToNonMockCall(rootQualifierOrSelf(name), ctx) || isNonHelperMethodCallOnMock(name); + } + + private static Expression rootQualifierOrSelf(Name name) { + Tree cursor = name; + while (cursor.parent() instanceof QualifiedExpression qualifiedExpression + && qualifiedExpression.qualifier() == cursor) { + cursor = qualifiedExpression; + } + return (Expression) cursor; + } + + private static boolean isArgumentToNonMockCall(Expression expression, SubscriptionContext ctx) { + if (!(expression.parent() instanceof RegularArgument)) { + return false; + } + CallExpression enclosingCall = (CallExpression) TreeUtils.firstAncestorOfKind(expression.parent(), Tree.Kind.CALL_EXPR); + return !MOCK_CLASS_MATCHER.isTrueFor(Expressions.removeParentheses(enclosingCall.callee()), ctx); + } + + private static boolean isNonHelperMethodCallOnMock(Name name) { + if (name.parent() instanceof CallExpression directCall && directCall.callee() == name) { + return true; + } + Tree cursor = name; + while (cursor.parent() instanceof QualifiedExpression qualifiedExpression + && qualifiedExpression.qualifier() == cursor) { + cursor = qualifiedExpression; + } + if (!(cursor instanceof QualifiedExpression qualifiedExpression)) { + return false; + } + if (!(cursor.parent() instanceof CallExpression callExpression) || callExpression.callee() != cursor) { + return false; + } + return !MOCK_HELPER_METHODS.contains(qualifiedExpression.name().name()); + } + + /** + * Isolation-only patches (unused mock) do not benefit from autospec. + */ + private static boolean patchMockIsUsedInTest(CallExpression patchCall, SubscriptionContext ctx) { + Decorator decorator = (Decorator) TreeUtils.firstAncestorOfKind(patchCall, Tree.Kind.DECORATOR); + if (decorator != null) { + if (decorator.parent() instanceof ClassDef) { + // Class-level @patch injects mocks into every method — keep raising. + return true; + } + FunctionDef functionDef = Objects.requireNonNull( + (FunctionDef) TreeUtils.firstAncestorOfKind(decorator, Tree.Kind.FUNCDEF)); + SymbolV2 mockSymbol = mockSymbolFromDecorator(functionDef, decorator, ctx); + return mockSymbol != null && hasNonBindingUsage(mockSymbol); + } + + WithItem withItem = (WithItem) TreeUtils.firstAncestorOfKind(patchCall, Tree.Kind.WITH_ITEM); + if (withItem != null && isPatchWithItem(withItem, patchCall)) { + if (!(withItem.expression() instanceof Name name)) { + return false; + } + SymbolV2 symbol = name.symbolV2(); + return symbol != null && hasNonBindingUsage(symbol); + } + + return Expressions.getAssignedName(patchCall) + .map(Name::symbolV2) + .filter(MocksShouldUseAutospecCheck::hasNonBindingUsage) + .isPresent(); + } + + private static boolean isPatchWithItem(WithItem withItem, CallExpression patchCall) { + return Expressions.removeParentheses(withItem.test()) == patchCall; + } + + private static boolean hasNonBindingUsage(SymbolV2 symbol) { + return symbol.usages().stream().anyMatch(usage -> !usage.isBindingUsage()); + } + + @CheckForNull + private static SymbolV2 mockSymbolFromDecorator(FunctionDef functionDef, Decorator decorator, SubscriptionContext ctx) { + List patchDecorators = new ArrayList<>(); + for (Decorator candidate : functionDef.decorators()) { + if (isPatchDecorator(candidate, ctx)) { + patchDecorators.add(candidate); + } + } + int indexFromTop = patchDecorators.indexOf(decorator); + // Bottom decorator maps to the first injected mock parameter. + int indexFromBottom = patchDecorators.size() - 1 - indexFromTop; + List mockParameters = mockParameters(functionDef); + if (indexFromBottom >= mockParameters.size()) { + return null; + } + Name parameterName = mockParameters.get(indexFromBottom).name(); + return parameterName != null ? parameterName.symbolV2() : null; + } + + private static boolean isPatchDecorator(Decorator decorator, SubscriptionContext ctx) { + Expression expression = Expressions.removeParentheses(decorator.expression()); + return expression instanceof CallExpression callExpression + && MockPatchUtils.newArgumentPosition(callExpression.callee(), ctx) >= 0; + } + + private static List mockParameters(FunctionDef functionDef) { + if (functionDef.parameters() == null) { + return List.of(); + } + List result = new ArrayList<>(); + for (Parameter parameter : functionDef.parameters().nonTuple()) { + Name parameterName = parameter.name(); + if (parameterName != null && !SELF.equals(parameterName.name()) && !CLS.equals(parameterName.name())) { + result.add(parameter); + } + } + return result; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/NotDiscoverableTestMethodCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/NotDiscoverableTestMethodCheck.java index a914eea75e..5451fdf8fb 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/tests/NotDiscoverableTestMethodCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/NotDiscoverableTestMethodCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -35,7 +35,7 @@ import org.sonar.plugins.python.api.tree.FunctionDef; import org.sonar.plugins.python.api.tree.Statement; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.tests.UnittestUtils; +import org.sonar.python.checks.utils.UnittestUtils; import org.sonar.python.tree.TreeUtils; @Rule(key = "S5899") diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestAutouseParametrizedFixtureCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestAutouseParametrizedFixtureCheck.java new file mode 100644 index 0000000000..7d491701b5 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestAutouseParametrizedFixtureCheck.java @@ -0,0 +1,87 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.ArgList; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8992") +public class PytestAutouseParametrizedFixtureCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove the \"params\" argument or set \"autouse\" to False."; + private static final String AUTOUSE_ARGUMENT = "autouse"; + private static final String PARAMS_ARGUMENT = "params"; + + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN("pytest.fixture"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.DECORATOR, PytestAutouseParametrizedFixtureCheck::checkDecorator); + } + + private static void checkDecorator(SubscriptionContext ctx) { + Decorator decorator = (Decorator) ctx.syntaxNode(); + Expression decoratorFunctionExpression = getDecoratorFunctionExpression(decorator); + if (!PYTEST_FIXTURE_MATCHER.isTrueFor(decoratorFunctionExpression, ctx)) { + return; + } + + ArgList argList = decorator.arguments(); + if (argList == null) { + return; + } + + RegularArgument autouseArgument = TreeUtils.argumentByKeyword(AUTOUSE_ARGUMENT, argList.arguments()); + if (autouseArgument == null || !Expressions.isTruthy(autouseArgument.expression())) { + return; + } + + RegularArgument paramsArgument = TreeUtils.argumentByKeyword(PARAMS_ARGUMENT, argList.arguments()); + if (paramsArgument == null || Expressions.isFalsy(paramsArgument.expression())) { + return; + } + + var keywordArgument = paramsArgument.keywordArgument(); + if (keywordArgument != null) { + ctx.addIssue(keywordArgument, MESSAGE); + } + } + + private static Expression getDecoratorFunctionExpression(Decorator decorator) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + return callExpression.callee(); + } + return expression; + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestDecoratorParenthesesCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestDecoratorParenthesesCheck.java new file mode 100644 index 0000000000..87c31ecc45 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestDecoratorParenthesesCheck.java @@ -0,0 +1,110 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import org.sonar.check.Rule; +import org.sonar.check.RuleProperty; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.Token; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.quickfix.TextEditUtils; + +@Rule(key = "S9083") +public class PytestDecoratorParenthesesCheck extends PythonSubscriptionCheck { + + private static final boolean DEFAULT_REQUIRE_PARENTHESES = false; + + private static final String REMOVE_MESSAGE = "Remove empty parentheses from this decorator."; + private static final String ADD_MESSAGE = "Add empty parentheses to this decorator."; + private static final String REMOVE_QUICK_FIX_MESSAGE = "Remove the empty parentheses"; + private static final String ADD_QUICK_FIX_MESSAGE = "Add empty parentheses"; + + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN("pytest.fixture"); + private static final TypeMatcher PYTEST_MARK_MATCHER = TypeMatchers.isType("pytest.mark"); + private static final TypeMatcher KNOWN_PYTEST_MARK_MATCHER = TypeMatchers.any( + TypeMatchers.isType("pytest.mark.skip"), + TypeMatchers.isType("pytest.mark.xfail"), + TypeMatchers.isType("pytest.mark.parametrize"), + TypeMatchers.isType("pytest.mark.usefixtures")); + + @RuleProperty( + key = "requireParentheses", + description = "Whether argument-free pytest fixture and mark decorators should use empty parentheses.", + defaultValue = "" + DEFAULT_REQUIRE_PARENTHESES) + public boolean requireParentheses = DEFAULT_REQUIRE_PARENTHESES; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.DECORATOR, this::checkDecorator); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private void checkDecorator(SubscriptionContext ctx) { + Expression expression = ((Decorator) ctx.syntaxNode()).expression(); + if (expression instanceof CallExpression callExpression) { + if (!requireParentheses && callExpression.arguments().isEmpty() && isPytestFixtureOrMark(callExpression.callee(), ctx)) { + raiseOnEmptyParentheses(ctx, callExpression); + } + } else if (requireParentheses && isPytestFixtureOrMark(expression, ctx)) { + raiseOnMissingParentheses(ctx, expression); + } + } + + private static void raiseOnEmptyParentheses(SubscriptionContext ctx, CallExpression callExpression) { + Token rightPar = callExpression.rightPar(); + var issue = ctx.addIssue(callExpression.leftPar(), rightPar, REMOVE_MESSAGE); + // A comment between the parentheses would be dropped along with them, so no fix is offered in that case. + if (rightPar.trivia().isEmpty()) { + Token calleeEnd = callExpression.callee().lastToken(); + issue.addQuickFix(PythonQuickFix.newQuickFix(REMOVE_QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.removeRange(calleeEnd.pythonLine(), endColumn(calleeEnd), rightPar.pythonLine(), endColumn(rightPar))) + .build()); + } + } + + private static void raiseOnMissingParentheses(SubscriptionContext ctx, Expression expression) { + ctx.addIssue(expression, ADD_MESSAGE) + .addQuickFix(PythonQuickFix.newQuickFix(ADD_QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.insertAfter(expression.lastToken(), "()")) + .build()); + } + + private static boolean isPytestFixtureOrMark(Expression expression, SubscriptionContext ctx) { + if (PYTEST_FIXTURE_MATCHER.isTrueFor(expression, ctx) || KNOWN_PYTEST_MARK_MATCHER.isTrueFor(expression, ctx)) { + return true; + } + // Custom marks have no stub, so they are recognized through the `pytest.mark` qualifier they are accessed on. + return expression instanceof QualifiedExpression qualifiedExpression + && PYTEST_MARK_MATCHER.isTrueFor(qualifiedExpression.qualifier(), ctx); + } + + private static int endColumn(Token token) { + return token.pythonColumn() + token.value().length(); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestDefaultFixtureScopeCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestDefaultFixtureScopeCheck.java new file mode 100644 index 0000000000..c71b5753c4 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestDefaultFixtureScopeCheck.java @@ -0,0 +1,145 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import java.util.Optional; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Token; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S9117") +public class PytestDefaultFixtureScopeCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove this redundant scope=\"function\" argument."; + private static final String QUICK_FIX_MESSAGE = "Remove scope=\"function\""; + private static final String SCOPE_ARGUMENT = "scope"; + private static final String FUNCTION_SCOPE = "function"; + + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.isType("pytest.fixture"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.DECORATOR, PytestDefaultFixtureScopeCheck::checkDecorator); + } + + private static void checkDecorator(SubscriptionContext ctx) { + Decorator decorator = (Decorator) ctx.syntaxNode(); + if (!(decorator.expression() instanceof CallExpression callExpression)) { + return; + } + if (!PYTEST_FIXTURE_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return; + } + + RegularArgument scopeArgument = TreeUtils.argumentByKeyword(SCOPE_ARGUMENT, callExpression.arguments()); + if (scopeArgument == null || !isFunctionScope(scopeArgument.expression())) { + return; + } + + var issue = ctx.addIssue(scopeArgument, MESSAGE); + createQuickFix(callExpression, scopeArgument).ifPresent(issue::addQuickFix); + } + + private static boolean isFunctionScope(Expression expression) { + return expression instanceof StringLiteral stringLiteral + && FUNCTION_SCOPE.equals(stringLiteral.trimmedQuotesValue()); + } + + private static Optional createQuickFix(CallExpression callExpression, RegularArgument scopeArgument) { + List arguments = callExpression.arguments(); + int argIndex = arguments.indexOf(scopeArgument); + if (argIndex == -1 || callExpression.argumentList() == null) { + return Optional.empty(); + } + + if (arguments.size() == 1) { + Token calleeEnd = callExpression.callee().lastToken(); + Token rightPar = callExpression.rightPar(); + return Optional.of(PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.removeRange( + calleeEnd.pythonLine(), + endColumn(calleeEnd), + rightPar.pythonLine(), + endColumn(rightPar))) + .build()); + } + + List children = callExpression.argumentList().children(); + int childIndex = children.indexOf(scopeArgument); + if (childIndex < 0) { + return Optional.empty(); + } + + if (argIndex == 0) { + // First argument: remove through the following comma. Prefer token-based removal when the + // next argument is on the same line, or when scope shares its line with '(' (so we do not + // delete the decorator). When scope is alone on its line, drop that whole line to keep the + // next argument's indentation. + Argument nextArg = arguments.get(1); + Token scopeToken = scopeArgument.firstToken(); + Token nextToken = nextArg.firstToken(); + if (scopeToken.line() == nextToken.line() || callExpression.leftPar().line() == scopeToken.line()) { + return Optional.of(PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.removeUntil(scopeArgument, nextArg)) + .build()); + } + return Optional.of(PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.removeRange( + scopeToken.pythonLine(), + 0, + nextToken.pythonLine(), + 0)) + .build()); + } + + // Not first: remove the preceding comma and this argument (keep any following comma / next-arg indent) + Tree removeFrom = children.get(childIndex - 1); + if (argIndex == arguments.size() - 1) { + return Optional.of(PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.removeUntil(removeFrom, callExpression.rightPar())) + .build()); + } + + Tree removeTo = children.get(childIndex + 1); + return Optional.of(PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.removeUntil(removeFrom, removeTo)) + .build()); + } + + private static int endColumn(Token token) { + return token.pythonColumn() + token.value().length(); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestFixtureMultipleYieldCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestFixtureMultipleYieldCheck.java new file mode 100644 index 0000000000..49bff25c08 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestFixtureMultipleYieldCheck.java @@ -0,0 +1,219 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.ArrayList; +import java.util.List; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.ElseClause; +import org.sonar.plugins.python.api.tree.ExceptClause; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FinallyClause; +import org.sonar.plugins.python.api.tree.ForStatement; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.IfStatement; +import org.sonar.plugins.python.api.tree.RaiseStatement; +import org.sonar.plugins.python.api.tree.ReturnStatement; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.StatementList; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.TryStatement; +import org.sonar.plugins.python.api.tree.WhileStatement; +import org.sonar.plugins.python.api.tree.WithStatement; +import org.sonar.plugins.python.api.tree.YieldStatement; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S8994") +public class PytestFixtureMultipleYieldCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Pytest fixtures should contain at most one yield statement."; + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN("pytest.fixture"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, PytestFixtureMultipleYieldCheck::checkFunctionDef); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkFunctionDef(SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + if (!isPytestFixture(functionDef, ctx)) { + return; + } + + YieldPathAnalyzer yieldPathAnalyzer = new YieldPathAnalyzer(); + yieldPathAnalyzer.analyze(functionDef.body()); + for (YieldStatement yieldStatement : yieldPathAnalyzer.violations()) { + ctx.addIssue(yieldStatement, MESSAGE); + } + } + + private static boolean isPytestFixture(FunctionDef functionDef, SubscriptionContext ctx) { + return functionDef.decorators().stream().anyMatch(decorator -> matchesPytestFixtureDecorator(decorator, ctx)); + } + + private static boolean matchesPytestFixtureDecorator(Decorator decorator, SubscriptionContext ctx) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + return PYTEST_FIXTURE_MATCHER.isTrueFor(callExpression.callee(), ctx); + } + return PYTEST_FIXTURE_MATCHER.isTrueFor(expression, ctx); + } + + private static final class YieldPathAnalyzer { + + private final List violations = new ArrayList<>(); + + void analyze(StatementList body) { + analyzeStatements(body.statements(), 0); + } + + List violations() { + return violations; + } + + private int analyzeStatements(List statements, int yieldsBefore) { + int yieldsSoFar = yieldsBefore; + for (Statement statement : statements) { + yieldsSoFar = analyzeStatement(statement, yieldsSoFar); + } + return yieldsSoFar; + } + + private int analyzeStatement(Statement statement, int yieldsBefore) { + if (statement instanceof YieldStatement yieldStatement) { + if (yieldsBefore >= 1) { + violations.add(yieldStatement); + } + return yieldsBefore + 1; + } + if (statement instanceof IfStatement ifStatement) { + return analyzeIfStatement(ifStatement, yieldsBefore); + } + if (statement instanceof TryStatement tryStatement) { + return analyzeTryStatement(tryStatement, yieldsBefore); + } + if (statement instanceof ForStatement forStatement) { + return analyzeLoopBody(forStatement.body(), forStatement.elseClause(), yieldsBefore); + } + if (statement instanceof WhileStatement whileStatement) { + return analyzeLoopBody(whileStatement.body(), whileStatement.elseClause(), yieldsBefore); + } + if (statement instanceof WithStatement withStatement) { + return analyzeStatements(withStatement.statements().statements(), yieldsBefore); + } + if (statement instanceof FunctionDef) { + return yieldsBefore; + } + return yieldsBefore; + } + + private int analyzeIfStatement(IfStatement ifStatement, int yieldsBefore) { + if (ifStatement.elseBranch() != null || !ifStatement.elifBranches().isEmpty()) { + return analyzeExclusiveBranches(ifStatement, yieldsBefore); + } + BranchResult ifBranch = analyzeBranch(ifStatement.body(), yieldsBefore); + return YieldPathAnalyzer.mergeBranchOutcomes(yieldsBefore, List.of(ifBranch)); + } + + private int analyzeExclusiveBranches(IfStatement ifStatement, int yieldsBefore) { + List branchResults = new ArrayList<>(); + branchResults.add(analyzeBranch(ifStatement.body(), yieldsBefore)); + for (IfStatement elifBranch : ifStatement.elifBranches()) { + branchResults.add(analyzeBranch(elifBranch.body(), yieldsBefore)); + } + ElseClause elseBranch = ifStatement.elseBranch(); + if (elseBranch != null) { + branchResults.add(analyzeBranch(elseBranch.body(), yieldsBefore)); + } + return YieldPathAnalyzer.mergeBranchOutcomes(yieldsBefore, branchResults); + } + + private static int mergeBranchOutcomes(int yieldsBefore, List branchResults) { + int maxAfter = yieldsBefore; + for (BranchResult branchResult : branchResults) { + if (branchResult.exits()) { + maxAfter = Math.max(maxAfter, yieldsBefore); + } else { + maxAfter = Math.max(maxAfter, branchResult.yieldsAfter()); + } + } + return maxAfter; + } + + private int analyzeTryStatement(TryStatement tryStatement, int yieldsBefore) { + List branchResults = new ArrayList<>(); + branchResults.add(analyzeBranch(tryStatement.body(), yieldsBefore)); + for (ExceptClause exceptClause : tryStatement.exceptClauses()) { + branchResults.add(analyzeBranch(exceptClause.body(), yieldsBefore)); + } + int maxAfter = YieldPathAnalyzer.mergeBranchOutcomes(yieldsBefore, branchResults); + ElseClause elseClause = tryStatement.elseClause(); + if (elseClause != null) { + maxAfter = analyzeStatements(elseClause.body().statements(), maxAfter); + } + FinallyClause finallyClause = tryStatement.finallyClause(); + if (finallyClause != null) { + maxAfter = analyzeStatements(finallyClause.body().statements(), maxAfter); + } + return maxAfter; + } + + private int analyzeLoopBody(StatementList body, @Nullable ElseClause elseClause, int yieldsBefore) { + int maxAfter = analyzeStatements(body.statements(), yieldsBefore); + if (elseClause != null) { + maxAfter = Math.max(maxAfter, analyzeStatements(elseClause.body().statements(), yieldsBefore)); + } + return maxAfter; + } + + private BranchResult analyzeBranch(StatementList body, int yieldsBefore) { + int yieldsAfter = analyzeStatements(body.statements(), yieldsBefore); + return new BranchResult(yieldsAfter, branchExits(body)); + } + + private static boolean branchExits(StatementList body) { + for (Statement statement : body.statements()) { + if (statement instanceof ReturnStatement || statement instanceof RaiseStatement) { + return true; + } + if (statement instanceof IfStatement ifStatement) { + if (branchExits(ifStatement.body()) || ifStatement.elifBranches().stream().anyMatch(elif -> branchExits(elif.body()))) { + return true; + } + ElseClause elseBranch = ifStatement.elseBranch(); + if (elseBranch != null && branchExits(elseBranch.body())) { + return true; + } + } + } + return false; + } + + private record BranchResult(int yieldsAfter, boolean exits) {} + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestFixturePositionalArgsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestFixturePositionalArgsCheck.java new file mode 100644 index 0000000000..076c3fe448 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestFixturePositionalArgsCheck.java @@ -0,0 +1,74 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.UnpackingExpression; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S9116") +public class PytestFixturePositionalArgsCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Pass fixture options as keyword arguments."; + + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN("pytest.fixture"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.DECORATOR, PytestFixturePositionalArgsCheck::checkDecorator); + } + + private static void checkDecorator(SubscriptionContext ctx) { + Decorator decorator = (Decorator) ctx.syntaxNode(); + if (!(decorator.expression() instanceof CallExpression callExpression)) { + return; + } + if (!PYTEST_FIXTURE_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return; + } + + for (Argument argument : callExpression.arguments()) { + if (isPositionalArgument(argument)) { + ctx.addIssue(argument, MESSAGE); + return; + } + } + } + + private static boolean isPositionalArgument(Argument argument) { + if (argument instanceof RegularArgument regularArgument) { + return regularArgument.keywordArgument() == null; + } + if (argument instanceof UnpackingExpression unpackingExpression) { + return "*".equals(unpackingExpression.starToken().value()); + } + return false; + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestFixtureYieldTeardownCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestFixtureYieldTeardownCheck.java new file mode 100644 index 0000000000..b29ebec1fa --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestFixtureYieldTeardownCheck.java @@ -0,0 +1,133 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.ArrayList; +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.BaseTreeVisitor; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.LambdaExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.YieldExpression; +import org.sonar.plugins.python.api.tree.YieldStatement; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.UnittestUtils; +import org.sonar.python.semantic.v2.typeshed.TypeShedConstants; + +@Rule(key = "S9080") +public class PytestFixtureYieldTeardownCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Replace this \"request.addfinalizer()\" call with a yield-based teardown."; + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN(UnittestUtils.PYTEST_FIXTURE_DECORATOR_FQN); + private static final TypeMatcher ADD_FINALIZER_MATCHER = TypeMatchers.isType(TypeShedConstants.PYTEST_FIXTURE_REQUEST_ADD_FINALIZER_FQN); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, PytestFixtureYieldTeardownCheck::checkFunctionDef); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkFunctionDef(SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + if (!isPytestFixture(functionDef, ctx)) { + return; + } + + var visitor = new FinalizerVisitor(ctx); + functionDef.body().accept(visitor); + if (visitor.hasYieldWithValue) { + return; + } + visitor.finalizerCallees.forEach(callee -> ctx.addIssue(callee, MESSAGE)); + } + + private static boolean isPytestFixture(FunctionDef functionDef, SubscriptionContext ctx) { + return functionDef.decorators().stream() + .anyMatch(decorator -> PYTEST_FIXTURE_MATCHER.isTrueFor(decoratorFunctionExpression(decorator), ctx)); + } + + private static Expression decoratorFunctionExpression(Decorator decorator) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + return callExpression.callee(); + } + return expression; + } + + /** + * Collects the {@code request.addfinalizer} calls registered by the fixture itself. Nested functions and lambdas are not + * visited: registering a finalizer there is the factory-as-fixture pattern, which cannot be expressed with a yield. + */ + private static class FinalizerVisitor extends BaseTreeVisitor { + + private final SubscriptionContext ctx; + private final List finalizerCallees = new ArrayList<>(); + private boolean hasYieldWithValue = false; + + FinalizerVisitor(SubscriptionContext ctx) { + this.ctx = ctx; + } + + @Override + public void visitCallExpression(CallExpression callExpression) { + Expression callee = callExpression.callee(); + if (ADD_FINALIZER_MATCHER.isTrueFor(callee, ctx)) { + finalizerCallees.add(callee); + } + super.visitCallExpression(callExpression); + } + + @Override + public void visitYieldStatement(YieldStatement yieldStatement) { + if (yieldsValue(yieldStatement.yieldExpression())) { + hasYieldWithValue = true; + } + } + + @Override + public void visitYieldExpression(YieldExpression yieldExpression) { + if (yieldsValue(yieldExpression)) { + hasYieldWithValue = true; + } + } + + private static boolean yieldsValue(YieldExpression yieldExpression) { + return !yieldExpression.expressions().isEmpty(); + } + + @Override + public void visitFunctionDef(FunctionDef functionDef) { + // nested functions belong to the factory-as-fixture pattern + } + + @Override + public void visitLambda(LambdaExpression lambdaExpression) { + // see visitFunctionDef + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestModuleImportCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestModuleImportCheck.java new file mode 100644 index 0000000000..271146fac0 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestModuleImportCheck.java @@ -0,0 +1,70 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AliasedName; +import org.sonar.plugins.python.api.tree.DottedName; +import org.sonar.plugins.python.api.tree.ImportFrom; +import org.sonar.plugins.python.api.tree.ImportName; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Tree; + +@Rule(key = "S9084") +public class PytestModuleImportCheck extends PythonSubscriptionCheck { + + private static final String PYTEST = "pytest"; + private static final String MESSAGE_FROM_IMPORT = "Import \"pytest\" as a module."; + private static final String MESSAGE_ALIASED_IMPORT = "Do not alias the \"pytest\" module."; + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.IMPORT_FROM, PytestModuleImportCheck::checkImportFrom); + context.registerSyntaxNodeConsumer(Tree.Kind.IMPORT_NAME, PytestModuleImportCheck::checkImportName); + } + + private static void checkImportFrom(SubscriptionContext ctx) { + ImportFrom importFrom = (ImportFrom) ctx.syntaxNode(); + DottedName module = importFrom.module(); + if (module != null && importFrom.dottedPrefixForModule().isEmpty() && isPytestModule(module)) { + ctx.addIssue(importFrom, MESSAGE_FROM_IMPORT); + } + } + + private static void checkImportName(SubscriptionContext ctx) { + ImportName importName = (ImportName) ctx.syntaxNode(); + for (AliasedName module : importName.modules()) { + Name alias = module.alias(); + if (alias != null && !PYTEST.equals(alias.name()) && isPytestModule(module.dottedName())) { + ctx.addIssue(module, MESSAGE_ALIASED_IMPORT); + } + } + } + + private static boolean isPytestModule(DottedName dottedName) { + List names = dottedName.names(); + return !names.isEmpty() && PYTEST.equals(names.get(0).name()); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestParameterDefaultValueCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestParameterDefaultValueCheck.java new file mode 100644 index 0000000000..3daa2f1272 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestParameterDefaultValueCheck.java @@ -0,0 +1,277 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.quickfix.PythonQuickFix; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FileInput; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Parameter; +import org.sonar.plugins.python.api.tree.ParameterList; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Token; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.UnittestUtils; +import org.sonar.python.quickfix.TextEditUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S9106") +public class PytestParameterDefaultValueCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Remove this default value so pytest can inject the parameter."; + private static final String QUICK_FIX_MESSAGE = "Remove default value"; + private static final String FIXTURE_NAME_ARGUMENT = "name"; + private static final String PARAMETRIZE_ARGNAMES = "argnames"; + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN(UnittestUtils.PYTEST_FIXTURE_DECORATOR_FQN); + private static final TypeMatcher PYTEST_PARAMETRIZE_MATCHER = TypeMatchers.isType("pytest.mark.parametrize"); + + /** + * Core pytest builtin fixture names. A default on a parameter with one of these names always + * blocks injection of that builtin fixture. + */ + private static final Set BUILTIN_FIXTURES = Set.of( + "request", + "tmp_path", + "tmpdir", + "tmp_path_factory", + "tmpdir_factory", + "monkeypatch", + "capsys", + "capfd", + "capfdbinary", + "capsysbinary", + "caplog", + "cache", + "doctest_namespace", + "pytestconfig", + "record_property", + "record_testsuite_property", + "recwarn", + "testdir", + "pytester"); + + private final Set moduleFixtures = new HashSet<>(); + private final Map> classFixtures = new HashMap<>(); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, this::collectFixtures); + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, this::checkFunctionDef); + } + + private void collectFixtures(SubscriptionContext ctx) { + moduleFixtures.clear(); + classFixtures.clear(); + moduleFixtures.addAll(BUILTIN_FIXTURES); + + FileInput fileInput = (FileInput) ctx.syntaxNode(); + if (fileInput.statements() == null) { + return; + } + for (Statement statement : fileInput.statements().statements()) { + collectFixtureFromStatement(statement, ctx); + } + } + + private void collectFixtureFromStatement(Statement statement, SubscriptionContext ctx) { + if (statement instanceof FunctionDef functionDef) { + addModuleFixture(functionDef, ctx); + } else if (statement instanceof ClassDef classDef) { + collectClassFixtures(classDef, ctx); + } + } + + private void addModuleFixture(FunctionDef functionDef, SubscriptionContext ctx) { + String name = fixtureName(functionDef, ctx); + if (name != null) { + moduleFixtures.add(name); + } + } + + private void collectClassFixtures(ClassDef classDef, SubscriptionContext ctx) { + Set fixtures = new HashSet<>(); + for (Statement bodyStatement : classDef.body().statements()) { + if (bodyStatement instanceof FunctionDef methodDef) { + String name = fixtureName(methodDef, ctx); + if (name != null) { + fixtures.add(name); + } + } + } + if (!fixtures.isEmpty()) { + classFixtures.put(classDef, fixtures); + } + } + + private void checkFunctionDef(SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + if (!isPytestTestOrFixture(functionDef, ctx)) { + return; + } + + ParameterList parameterList = functionDef.parameters(); + if (parameterList == null) { + return; + } + + Set injectedNames = injectedParameterNames(functionDef, ctx); + for (Parameter parameter : parameterList.nonTuple()) { + reportDefaultIfInjected(ctx, parameter, injectedNames); + } + } + + /** + * Names pytest will inject for this function: known fixtures in scope, plus statically known + * {@code @pytest.mark.parametrize} argnames. + */ + private Set injectedParameterNames(FunctionDef functionDef, SubscriptionContext ctx) { + Set injected = new HashSet<>(moduleFixtures); + ClassDef enclosingClass = CheckUtils.getParentClassDef(functionDef); + if (enclosingClass != null) { + Set fixtures = classFixtures.get(enclosingClass); + if (fixtures != null) { + injected.addAll(fixtures); + } + } + injected.addAll(parametrizeArgNames(functionDef, ctx)); + return injected; + } + + private static Set parametrizeArgNames(FunctionDef functionDef, SubscriptionContext ctx) { + return functionDef.decorators().stream() + .flatMap(decorator -> parametrizeArgNames(decorator, ctx)) + .collect(Collectors.toSet()); + } + + private static Stream parametrizeArgNames(Decorator decorator, SubscriptionContext ctx) { + Expression expression = decorator.expression(); + if (!(expression instanceof CallExpression callExpression) + || !PYTEST_PARAMETRIZE_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return Stream.empty(); + } + RegularArgument argNamesArgument = TreeUtils.nthArgumentOrKeyword(0, PARAMETRIZE_ARGNAMES, callExpression.arguments()); + if (argNamesArgument == null) { + return Stream.empty(); + } + Expression argNames = Expressions.removeParentheses(argNamesArgument.expression()); + if (argNames instanceof StringLiteral stringLiteral) { + return Arrays.stream(stringLiteral.trimmedQuotesValue().split(",")) + .map(String::trim) + .filter(name -> !name.isEmpty()); + } + return Expressions.expressionsFromListOrTuple(argNames).stream() + .map(Expressions::removeParentheses) + .flatMap(TreeUtils.toStreamInstanceOfMapper(StringLiteral.class)) + .map(StringLiteral::trimmedQuotesValue) + .map(String::trim) + .filter(name -> !name.isEmpty()); + } + + private static void reportDefaultIfInjected(SubscriptionContext ctx, Parameter parameter, Set injectedNames) { + if (parameter.starToken() != null || parameter.name() == null) { + return; + } + Expression defaultValue = parameter.defaultValue(); + if (defaultValue == null) { + return; + } + String parameterName = parameter.name().name(); + if (!injectedNames.contains(parameterName)) { + return; + } + + var issue = ctx.addIssue(defaultValue, MESSAGE); + Token previousToken = parameter.typeAnnotation() != null + ? parameter.typeAnnotation().lastToken() + : parameter.name().lastToken(); + issue.addQuickFix(PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE) + .addTextEdit(TextEditUtils.removeRange( + previousToken.pythonLine(), + endColumn(previousToken), + defaultValue.lastToken().pythonLine(), + endColumn(defaultValue.lastToken()))) + .build()); + } + + private static boolean isPytestTestOrFixture(FunctionDef functionDef, SubscriptionContext ctx) { + return isPytestFixture(functionDef, ctx) + || UnittestUtils.isCollectedPytestTestFunction(functionDef, ctx.pythonFile().fileName()); + } + + private static boolean isPytestFixture(FunctionDef functionDef, SubscriptionContext ctx) { + return functionDef.decorators().stream() + .anyMatch(decorator -> PYTEST_FIXTURE_MATCHER.isTrueFor(decoratorFunctionExpression(decorator), ctx)); + } + + /** + * Returns the pytest fixture name for this function, honoring {@code @pytest.fixture(name=...)}, + * or {@code null} if the function is not a fixture. + */ + private static String fixtureName(FunctionDef functionDef, SubscriptionContext ctx) { + for (Decorator decorator : functionDef.decorators()) { + Expression expression = decorator.expression(); + Expression callee = decoratorFunctionExpression(decorator); + if (!PYTEST_FIXTURE_MATCHER.isTrueFor(callee, ctx)) { + continue; + } + if (expression instanceof CallExpression callExpression) { + RegularArgument nameArgument = TreeUtils.argumentByKeyword(FIXTURE_NAME_ARGUMENT, callExpression.arguments()); + if (nameArgument != null && nameArgument.expression() instanceof StringLiteral stringLiteral) { + return stringLiteral.trimmedQuotesValue(); + } + } + return functionDef.name().name(); + } + return null; + } + + private static Expression decoratorFunctionExpression(Decorator decorator) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + return callExpression.callee(); + } + return expression; + } + + private static int endColumn(Token token) { + return token.pythonColumn() + token.value().length(); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestPluginsConftestCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestPluginsConftestCheck.java new file mode 100644 index 0000000000..11bbdc87f9 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestPluginsConftestCheck.java @@ -0,0 +1,85 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import java.util.Optional; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.AnnotatedAssignment; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8999") +public class PytestPluginsConftestCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "\"pytest_plugins\" should be defined in conftest.py files"; + private static final String PYTEST_PLUGINS = "pytest_plugins"; + private static final String CONFTEST_FILE_NAME = "conftest.py"; + + @Override + public CheckScope scope() { + return CheckScope.TESTS; + } + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.ASSIGNMENT_STMT, PytestPluginsConftestCheck::onAssignment); + context.registerSyntaxNodeConsumer(Tree.Kind.ANNOTATED_ASSIGNMENT, PytestPluginsConftestCheck::onAssignment); + } + + private static void onAssignment(SubscriptionContext ctx) { + checkPytestPluginsAssignment(ctx, ctx.syntaxNode()); + } + + private static void checkPytestPluginsAssignment(SubscriptionContext ctx, Tree assignment) { + if (CONFTEST_FILE_NAME.equals(ctx.pythonFile().fileName()) || !isModuleLevel(assignment)) { + return; + } + getPytestPluginsTarget(assignment).ifPresent(target -> ctx.addIssue(target, MESSAGE)); + } + + private static boolean isModuleLevel(Tree assignment) { + return TreeUtils.firstAncestorOfKind(assignment, Tree.Kind.FUNCDEF, Tree.Kind.CLASSDEF) == null; + } + + private static Optional getPytestPluginsTarget(Tree assignment) { + if (assignment instanceof AssignmentStatement assignmentStatement) { + return assignmentStatement.lhsExpressions().stream() + .map(ExpressionList::expressions) + .flatMap(List::stream) + .filter(PytestPluginsConftestCheck::isPytestPluginsName) + .findFirst(); + } + if (assignment instanceof AnnotatedAssignment annotatedAssignment) { + Expression lhs = annotatedAssignment.variable(); + if (isPytestPluginsName(lhs) && annotatedAssignment.assignedValue() != null) { + return Optional.of(lhs); + } + } + return Optional.empty(); + } + + private static boolean isPytestPluginsName(Expression expression) { + return expression.is(Tree.Kind.NAME) && PYTEST_PLUGINS.equals(((Name) expression).name()); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestRaisesContextManagerCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestRaisesContextManagerCheck.java new file mode 100644 index 0000000000..5054145f8e --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestRaisesContextManagerCheck.java @@ -0,0 +1,94 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionStatement; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.python.checks.utils.UnittestUtils; + +@Rule(key = "S9000") +public class PytestRaisesContextManagerCheck extends PythonSubscriptionCheck { + private static final String MESSAGE = "Prefer the context manager form: wrap the raising code in \"with pytest.raises(...)\"."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> checkCallExpression(ctx, (CallExpression) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkCallExpression(SubscriptionContext ctx, CallExpression callExpression) { + if (!UnittestUtils.isPytestRaises(callExpression, ctx)) { + return; + } + // Only raise when sure: discarded expression-statement calls, or the deprecated callable form. + // Assigned / nested / parametrize / returned values are left alone (prefer FN over FP). + if (isDeprecatedCallableForm(callExpression) || isStandaloneExpressionStatement(callExpression)) { + ctx.addIssue(callExpression, MESSAGE); + } + } + + /** + * Deprecated {@code pytest.raises(exc, callable, *args, **kwargs)} form always executes immediately + * and must be migrated to a {@code with} block — safe to report in any syntactic position. + */ + private static boolean isDeprecatedCallableForm(CallExpression callExpression) { + return secondPositionalArgument(callExpression.arguments()) != null; + } + + private static RegularArgument secondPositionalArgument(List arguments) { + int positionalIndex = 0; + for (Argument argument : arguments) { + if (!(argument instanceof RegularArgument regularArgument) || regularArgument.keywordArgument() != null) { + continue; + } + if (positionalIndex == 1) { + return regularArgument; + } + positionalIndex++; + } + return null; + } + + /** + * {@code pytest.raises(...)} used as a bare expression statement discards the context manager — + * safe to report. Nested uses (assignment RHS, call args, {@code with} items, etc.) are not. + */ + private static boolean isStandaloneExpressionStatement(CallExpression callExpression) { + Expression expression = outermostParenthesized(callExpression); + return expression.parent() instanceof ExpressionStatement; + } + + private static Expression outermostParenthesized(Expression expression) { + Expression current = expression; + while (current.parent() != null && current.parent().is(Tree.Kind.PARENTHESIZED)) { + current = (Expression) current.parent(); + } + return current; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/PytestUselessYieldFixtureCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestUselessYieldFixtureCheck.java new file mode 100644 index 0000000000..d19abf9e19 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/PytestUselessYieldFixtureCheck.java @@ -0,0 +1,117 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.BaseTreeVisitor; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.LambdaExpression; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.YieldExpression; +import org.sonar.plugins.python.api.tree.YieldStatement; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.UnittestUtils; + +@Rule(key = "S9100") +public class PytestUselessYieldFixtureCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE_USE_RETURN = "No teardown in this fixture. Use \"return\" instead of \"yield\"."; + private static final String MESSAGE_REMOVE_YIELD = "Remove this useless \"yield\"."; + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN(UnittestUtils.PYTEST_FIXTURE_DECORATOR_FQN); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, PytestUselessYieldFixtureCheck::checkFunctionDef); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkFunctionDef(SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + if (!isPytestFixture(functionDef, ctx) || CheckUtils.isAbstract(functionDef)) { + return; + } + + List statements = functionDef.body().statements(); + if (statements.isEmpty()) { + return; + } + + Statement last = statements.get(statements.size() - 1); + if (!(last instanceof YieldStatement yieldStatement)) { + return; + } + // "yield from" delegates teardown to another generator (Ruff PT022 ignores it). + if (yieldStatement.yieldExpression().fromKeyword() != null) { + return; + } + + // Multiple yields are covered by S8994; telling the user to "return" / remove the last + // yield would be wrong advice when an earlier yield already made this a generator fixture. + // Same guard as Ruff PT022 (exactly one yield in the fixture body). + YieldCounter yieldCounter = new YieldCounter(); + functionDef.body().accept(yieldCounter); + if (yieldCounter.count == 1) { + boolean bareYield = yieldStatement.yieldExpression().expressions().isEmpty(); + ctx.addIssue(yieldStatement, bareYield ? MESSAGE_REMOVE_YIELD : MESSAGE_USE_RETURN); + } + } + + private static boolean isPytestFixture(FunctionDef functionDef, SubscriptionContext ctx) { + return functionDef.decorators().stream() + .anyMatch(decorator -> PYTEST_FIXTURE_MATCHER.isTrueFor(decoratorFunctionExpression(decorator), ctx)); + } + + private static Expression decoratorFunctionExpression(Decorator decorator) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + return callExpression.callee(); + } + return expression; + } + + private static final class YieldCounter extends BaseTreeVisitor { + private int count; + + @Override + public void visitFunctionDef(FunctionDef functionDef) { + // Skip nested functions + } + + @Override + public void visitLambda(LambdaExpression lambdaExpression) { + // Skip lambdas + } + + @Override + public void visitYieldExpression(YieldExpression yieldExpression) { + count++; + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/SingleInvocationRuntimeExceptionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/SingleInvocationRuntimeExceptionCheck.java new file mode 100644 index 0000000000..f7322d99ce --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/SingleInvocationRuntimeExceptionCheck.java @@ -0,0 +1,114 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import java.util.Optional; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.LambdaExpression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.WithItem; +import org.sonar.plugins.python.api.tree.WithStatement; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.SingleInvocationUtils; +import org.sonar.python.checks.utils.UnittestUtils; + +@Rule(key = "S5778") +public class SingleInvocationRuntimeExceptionCheck extends PythonSubscriptionCheck { + private static final String MESSAGE = "Refactor this exception test to have only one invocation possibly throwing an exception."; + private static final String SECONDARY_MESSAGE = "Invocation possibly throwing an exception."; + + private static final TypeMatcher PYTEST_RAISES_MATCHER = TypeMatchers.isType("pytest.raises"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.WITH_STMT, ctx -> checkWithStatement(ctx, (WithStatement) ctx.syntaxNode())); + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> checkDirectRaiseCall(ctx, (CallExpression) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkWithStatement(SubscriptionContext ctx, WithStatement withStatement) { + boolean isRaiseAssertion = withStatement.withItems().stream() + .map(WithItem::test) + .filter(CallExpression.class::isInstance) + .map(CallExpression.class::cast) + .anyMatch(callExpression -> isPytestRaise(callExpression, ctx) || isUnittestRaise(callExpression)); + + if (!isRaiseAssertion) { + return; + } + + var invocations = SingleInvocationUtils.unsafeInvocations(withStatement.statements(), ctx); + if (invocations.size() > 1) { + SingleInvocationUtils.reportIfMultipleInvocations( + ctx.addIssue(withStatement.withKeyword(), withStatement.colon(), MESSAGE), + invocations, + SECONDARY_MESSAGE); + } + } + + private static void checkDirectRaiseCall(SubscriptionContext ctx, CallExpression callExpression) { + if (!isPytestRaise(callExpression, ctx) && !isUnittestRaise(callExpression)) { + return; + } + + findLambdaArgument(callExpression.arguments()) + .map(lambdaExpression -> SingleInvocationUtils.unsafeInvocations(lambdaExpression.expression(), ctx)) + .filter(invocations -> invocations.size() > 1) + .ifPresent(invocations -> SingleInvocationUtils.reportIfMultipleInvocations( + ctx.addIssue(callExpression, MESSAGE), + invocations, + SECONDARY_MESSAGE)); + } + + private static boolean isPytestRaise(CallExpression callExpression, SubscriptionContext ctx) { + return PYTEST_RAISES_MATCHER.isTrueFor(callExpression.callee(), ctx); + } + + private static boolean isUnittestRaise(CallExpression callExpression) { + if (!(callExpression.callee() instanceof QualifiedExpression qualifiedExpression)) { + return false; + } + if (!(qualifiedExpression.qualifier() instanceof Name qualifier) || !"self".equals(qualifier.name())) { + return false; + } + return UnittestUtils.isWithinUnittestTestCase(callExpression) + && UnittestUtils.RAISE_METHODS.contains(qualifiedExpression.name().name()); + } + + private static Optional findLambdaArgument(List arguments) { + return arguments.stream() + .filter(RegularArgument.class::isInstance) + .map(RegularArgument.class::cast) + .map(RegularArgument::expression) + .filter(LambdaExpression.class::isInstance) + .map(LambdaExpression.class::cast) + .findFirst(); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/SingleInvocationWarningCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/SingleInvocationWarningCheck.java new file mode 100644 index 0000000000..14e1c43a89 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/SingleInvocationWarningCheck.java @@ -0,0 +1,63 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.WithItem; +import org.sonar.plugins.python.api.tree.WithStatement; +import org.sonar.python.checks.utils.SingleInvocationUtils; +import org.sonar.python.checks.utils.UnittestUtils; + +@Rule(key = "S9088") +public class SingleInvocationWarningCheck extends PythonSubscriptionCheck { + private static final String MESSAGE = "Refactor this warning test to have only one invocation possibly emitting a warning."; + private static final String SECONDARY_MESSAGE = "Invocation possibly emitting a warning."; + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.WITH_STMT, ctx -> checkWithStatement(ctx, (WithStatement) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkWithStatement(SubscriptionContext ctx, WithStatement withStatement) { + boolean isWarnsAssertion = withStatement.withItems().stream() + .map(WithItem::test) + .filter(CallExpression.class::isInstance) + .map(CallExpression.class::cast) + .anyMatch(callExpression -> UnittestUtils.isPytestWarns(callExpression, ctx)); + + if (!isWarnsAssertion) { + return; + } + + var invocations = SingleInvocationUtils.unsafeInvocations(withStatement.statements(), ctx); + if (invocations.size() > 1) { + SingleInvocationUtils.reportIfMultipleInvocations( + ctx.addIssue(withStatement.withKeyword(), withStatement.colon(), MESSAGE), + invocations, + SECONDARY_MESSAGE); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/SkippedTestNoReasonCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/SkippedTestNoReasonCheck.java index 3932e155c2..bcb44d6998 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/tests/SkippedTestNoReasonCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/SkippedTestNoReasonCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/SpecificExceptionAssertionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/SpecificExceptionAssertionCheck.java new file mode 100644 index 0000000000..a93ff9cbf7 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/SpecificExceptionAssertionCheck.java @@ -0,0 +1,98 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.WithItem; +import org.sonar.plugins.python.api.tree.WithStatement; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.UnittestUtils; + +import static org.sonar.plugins.python.api.types.BuiltinTypes.BASE_EXCEPTION; +import static org.sonar.plugins.python.api.types.BuiltinTypes.EXCEPTION; + +@Rule(key = "S5958") +public class SpecificExceptionAssertionCheck extends PythonSubscriptionCheck { + private static final String MESSAGE = "This assertion is too broad; use a more specific exception type or check the exception message."; + private static final TypeMatcher GENERIC_EXCEPTION_MATCHER = TypeMatchers.any( + TypeMatchers.isObjectOfType(EXCEPTION), + TypeMatchers.isObjectOfType(BASE_EXCEPTION), + TypeMatchers.isType(EXCEPTION), + TypeMatchers.isType(BASE_EXCEPTION) + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.WITH_STMT, ctx -> checkWithStatement(ctx, (WithStatement) ctx.syntaxNode())); + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> checkCallExpression(ctx, (CallExpression) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkWithStatement(SubscriptionContext ctx, WithStatement withStatement) { + for (WithItem withItem : withStatement.withItems()) { + if (!(withItem.test() instanceof CallExpression callExpression)) { + continue; + } + Expression issueLocation = genericExceptionArgument(callExpression, ctx); + if (issueLocation != null) { + ctx.addIssue(issueLocation, MESSAGE); + } + } + } + + private static void checkCallExpression(SubscriptionContext ctx, CallExpression callExpression) { + if (callExpression.parent().is(Tree.Kind.WITH_ITEM)) { + return; + } + Expression issueLocation = genericExceptionArgument(callExpression, ctx); + if (issueLocation != null) { + ctx.addIssue(issueLocation, MESSAGE); + } + } + + @Nullable + private static Expression genericExceptionArgument(CallExpression callExpression, SubscriptionContext ctx) { + RegularArgument exceptionArgument = null; + if (UnittestUtils.isPytestRaises(callExpression, ctx)) { + if (UnittestUtils.pytestMatchArgument(callExpression) != null) { + return null; + } + exceptionArgument = UnittestUtils.pytestExpectedExceptionArgument(callExpression); + } else if (UnittestUtils.isUnittestAssertRaises(callExpression, ctx)) { + if (UnittestUtils.hasUnittestAssertRaisesMessageCheck(callExpression, ctx)) { + return null; + } + exceptionArgument = UnittestUtils.unittestExceptionArgument(callExpression); + } + if (exceptionArgument == null || !GENERIC_EXCEPTION_MATCHER.isTrueFor(exceptionArgument.expression(), ctx)) { + return null; + } + return exceptionArgument.expression(); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/SpecificWarningAssertionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/SpecificWarningAssertionCheck.java new file mode 100644 index 0000000000..febc66b506 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/SpecificWarningAssertionCheck.java @@ -0,0 +1,97 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.UnittestUtils; + +@Rule(key = "S9075") +public class SpecificWarningAssertionCheck extends PythonSubscriptionCheck { + private static final String MESSAGE = "This assertion is too broad; use a more specific warning type or check the warning message."; + + private static final TypeMatcher BROAD_WARNING_MATCHER = TypeMatchers.any( + TypeMatchers.isType("Warning"), + TypeMatchers.isObjectOfType("Warning") + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> checkCallExpression(ctx, (CallExpression) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkCallExpression(SubscriptionContext ctx, CallExpression callExpression) { + Expression issueLocation = underspecifiedWarningArgument(callExpression, ctx); + if (issueLocation != null) { + ctx.addIssue(issueLocation, MESSAGE); + } + } + + @Nullable + private static Expression underspecifiedWarningArgument(CallExpression callExpression, SubscriptionContext ctx) { + if (!UnittestUtils.isPytestWarns(callExpression, ctx)) { + return null; + } + if (hasEffectiveMatchArgument(callExpression)) { + return null; + } + RegularArgument warningArgument = UnittestUtils.pytestExpectedWarningArgument(callExpression); + if (warningArgument == null) { + return callExpression; + } + return broadWarningLocation(warningArgument.expression(), ctx); + } + + @Nullable + private static Expression broadWarningLocation(Expression expression, SubscriptionContext ctx) { + Expression unwrapped = Expressions.removeParentheses(expression); + List elements = Expressions.expressionsFromListOrTuple(unwrapped); + if (!elements.isEmpty()) { + for (Expression element : elements) { + Expression location = broadWarningLocation(element, ctx); + if (location != null) { + return location; + } + } + return null; + } + if (BROAD_WARNING_MATCHER.isTrueFor(unwrapped, ctx)) { + return unwrapped; + } + return null; + } + + private static boolean hasEffectiveMatchArgument(CallExpression callExpression) { + RegularArgument matchArgument = UnittestUtils.pytestMatchArgument(callExpression); + return matchArgument != null && !Expressions.isFalsy(matchArgument.expression()); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/TestCasesShouldContainTestsCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/TestCasesShouldContainTestsCheck.java new file mode 100644 index 0000000000..5c79a1afcc --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/TestCasesShouldContainTestsCheck.java @@ -0,0 +1,235 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Objects; +import java.util.Set; +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.ClassSymbol; +import org.sonar.plugins.python.api.symbols.Symbol; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FileInput; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.RaiseStatement; +import org.sonar.plugins.python.api.tree.Statement; +import org.sonar.plugins.python.api.tree.StatementList; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.UnittestUtils; + +import static java.util.function.Predicate.not; +import static org.sonar.python.tree.TreeUtils.getClassSymbolFromDef; + +@Rule(key = "S2187") +public class TestCasesShouldContainTestsCheck extends PythonSubscriptionCheck { + private static final String CLASS_MESSAGE = "Add some tests to this class."; + private static final String FILE_MESSAGE = "Add some tests to this file."; + private static final TypeMatcher ABSTRACT_BASE_CLASS_MATCHER = TypeMatchers.isOrExtendsType("abc.ABC"); + private static final TypeMatcher NOT_IMPLEMENTED_ERROR_MATCHER = TypeMatchers.any( + TypeMatchers.isType("builtins.NotImplementedError"), + TypeMatchers.isObjectInstanceOf("builtins.NotImplementedError")); + + @Override + public CheckScope scope() { + return CheckScope.TESTS; + } + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, TestCasesShouldContainTestsCheck::checkFileInput); + } + + private static void checkFileInput(SubscriptionContext ctx) { + FileInput fileInput = (FileInput) ctx.syntaxNode(); + StatementList statements = fileInput.statements(); + if (statements == null) { + return; + } + + boolean pytestStyleFile = UnittestUtils.isPytestFileName(ctx.pythonFile().fileName()); + List classes = collectClasses(ctx, statements, pytestStyleFile); + List candidateClasses = classes.stream() + .filter(ClassInfo::isCandidate) + .toList(); + boolean hasCollectedTests = hasModuleLevelPytestTests(statements) || hasClassLevelTests(statements); + + if (pytestStyleFile && !hasCollectedTests) { + ctx.addFileIssue(FILE_MESSAGE); + return; + } + + candidateClasses + .stream() + .filter(not(ClassInfo::hasCollectedTests)) + .filter(candidateClass -> !hasDescendantWithTests(candidateClass, classes)) + .filter(candidateClass -> !isLikelySharedBaseClass(candidateClass, ctx)) + .forEach(candidateClass -> ctx.addIssue(candidateClass.classDef().name(), CLASS_MESSAGE)); + } + + private static List collectClasses(SubscriptionContext ctx, StatementList statements, boolean pytestStyleFile) { + return statements.statements() + .stream().filter(ClassDef.class::isInstance) + .map(ClassDef.class::cast) + .map(classDef -> { + ClassSymbol classSymbol = getClassSymbolFromDef(classDef); + return new ClassInfo(classDef, classSymbol, hasCollectedTests(classDef), isCandidateTestClass(ctx, classDef, pytestStyleFile)); + }) + .toList(); + } + + private static boolean hasModuleLevelPytestTests(StatementList statements) { + return statements.statements().stream() + .filter(FunctionDef.class::isInstance) + .map(FunctionDef.class::cast) + .anyMatch(TestCasesShouldContainTestsCheck::isCollectedTestMethod); + } + + private static boolean hasClassLevelTests(StatementList statements) { + return statements.statements().stream() + .filter(ClassDef.class::isInstance) + .map(ClassDef.class::cast) + .anyMatch(TestCasesShouldContainTestsCheck::hasCollectedTests); + } + + private static boolean isCandidateTestClass(SubscriptionContext ctx, ClassDef classDef, boolean pytestStyleFile) { + return (pytestStyleFile && UnittestUtils.isPytestStyleTestClass(classDef, ctx.pythonFile().fileName())) + || UnittestUtils.isUnittestTestCaseClass(classDef); + } + + private static boolean hasCollectedTests(ClassDef classDef) { + return hasLocalTestMethod(classDef) || hasInheritedTestMethod(classDef); + } + + private static boolean hasLocalTestMethod(ClassDef classDef) { + return classDef.body().statements().stream() + .filter(FunctionDef.class::isInstance) + .map(FunctionDef.class::cast) + .anyMatch(TestCasesShouldContainTestsCheck::isCollectedTestMethod); + } + + private static boolean hasInheritedTestMethod(ClassDef classDef) { + ClassSymbol classSymbol = getClassSymbolFromDef(classDef); + return classSymbol != null && superClassesDeclareTests(classSymbol, new LinkedHashSet<>()); + } + + private static boolean superClassesDeclareTests(ClassSymbol classSymbol, Set visitedSymbols) { + if (!visitedSymbols.add(classSymbol)) { + return false; + } + return classSymbol.superClasses().stream() + .filter(ClassSymbol.class::isInstance) + .map(ClassSymbol.class::cast) + .anyMatch(superClassSymbol -> + superClassesDeclareTests(superClassSymbol, visitedSymbols) || + superClassSymbol.declaredMembers().stream() + .filter(symbol -> symbol.is(Symbol.Kind.FUNCTION)) + .map(Symbol::name) + .anyMatch(TestCasesShouldContainTestsCheck::isTestMethodName) + ); + } + + private static boolean hasDescendantWithTests(ClassInfo candidateClass, List classes) { + ClassSymbol classSymbol = candidateClass.classSymbol(); + if (classSymbol == null) { + return false; + } + return classes.stream() + .filter(other -> other != candidateClass) + .filter(ClassInfo::hasCollectedTests) + .map(ClassInfo::classSymbol) + .filter(Objects::nonNull) + .anyMatch(otherClassSymbol -> otherClassSymbol.isOrExtends(classSymbol)); + } + + private static boolean isLikelySharedBaseClass(ClassInfo candidateClass, SubscriptionContext ctx) { + ClassDef classDef = candidateClass.classDef(); + String className = classDef.name().name(); + return className.startsWith("Base") + || className.endsWith("Mixin") + || isAbstractBaseClass(classDef, candidateClass.classSymbol(), ctx) + || onlyContainsPlaceholderMethods(classDef, ctx); + } + + private static boolean isAbstractBaseClass(ClassDef classDef, @Nullable ClassSymbol classSymbol, SubscriptionContext ctx) { + return classSymbol != null && (classSymbol.hasMetaClass() + || hasAncestorMatching(classDef, ABSTRACT_BASE_CLASS_MATCHER, ctx)); + } + + private static boolean hasAncestorMatching(ClassDef classDef, TypeMatcher matcher, SubscriptionContext ctx) { + var args = classDef.args(); + if (args == null) { + return false; + } + for (var argument : args.arguments()) { + if (argument instanceof RegularArgument regularArgument && matcher.isTrueFor(regularArgument.expression(), ctx)) { + return true; + } + } + return false; + } + + private static boolean onlyContainsPlaceholderMethods(ClassDef classDef, SubscriptionContext ctx) { + return classDef.body().statements().stream() + .filter(FunctionDef.class::isInstance) + .map(FunctionDef.class::cast) + .findAny() + .filter(functionDef -> classDef.body().statements().stream() + .filter(FunctionDef.class::isInstance) + .map(FunctionDef.class::cast) + .allMatch(method -> isPlaceholderMethod(method, ctx))) + .isPresent(); + } + + private static boolean isPlaceholderMethod(FunctionDef functionDef, SubscriptionContext ctx) { + List statements = functionDef.body().statements(); + return statements.size() == 1 && isPlaceholderStatement(statements.get(0), ctx); + } + + private static boolean isPlaceholderStatement(Statement statement, SubscriptionContext ctx) { + return statement.is(Tree.Kind.PASS_STMT) || isNotImplementedErrorRaise(statement, ctx); + } + + private static boolean isNotImplementedErrorRaise(Statement statement, SubscriptionContext ctx) { + if (!(statement instanceof RaiseStatement raiseStatement) || raiseStatement.expressions().size() != 1) { + return false; + } + return isNotImplementedError(raiseStatement.expressions().get(0), ctx); + } + + private static boolean isNotImplementedError(Expression expression, SubscriptionContext ctx) { + return NOT_IMPLEMENTED_ERROR_MATCHER.isTrueFor(expression, ctx); + } + + private static boolean isCollectedTestMethod(FunctionDef functionDef) { + return UnittestUtils.isTestMethodName(functionDef.name().name()); + } + + private static boolean isTestMethodName(String name) { + return UnittestUtils.isTestMethodName(name); + } + + private record ClassInfo(ClassDef classDef, @Nullable ClassSymbol classSymbol, boolean hasCollectedTests, boolean isCandidate) { + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/UnconditionalAssertionCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/UnconditionalAssertionCheck.java index 3ed7546afa..186e179909 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/tests/UnconditionalAssertionCheck.java +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/UnconditionalAssertionCheck.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -34,7 +34,6 @@ import org.sonar.plugins.python.api.tree.NumericLiteral; import org.sonar.plugins.python.api.tree.RegularArgument; import org.sonar.plugins.python.api.tree.Tree; -import org.sonar.python.cfg.fixpoint.ReachingDefinitionsAnalysis; import org.sonar.python.checks.utils.CheckUtils; import org.sonar.python.tree.TreeUtils; @@ -58,13 +57,8 @@ public class UnconditionalAssertionCheck extends PythonSubscriptionCheck { private static final Set ACCEPTED_DECORATORS = Set.of("overload", "staticmethod", "classmethod"); - private ReachingDefinitionsAnalysis reachingDefinitionsAnalysis; - @Override public void initialize(Context context) { - context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> - reachingDefinitionsAnalysis = new ReachingDefinitionsAnalysis(ctx.pythonFile())); - context.registerSyntaxNodeConsumer(Tree.Kind.ASSERT_STMT, ctx -> { AssertStatement assertStatement = (AssertStatement) ctx.syntaxNode(); Expression condition = assertStatement.condition(); @@ -109,19 +103,23 @@ private static boolean isFalseOrZeroLiteral(Expression expression) { return "False".equals(((Name) expression).name()); } if (expression.is(NUMERIC_LITERAL)) { - return ((NumericLiteral) expression).valueAsLong() == 0; + try { + return ((NumericLiteral) expression).valueAsLong() == 0; + } catch (NumberFormatException nfe) { + return false; + } } return false; } - private void checkNoneAssertion(SubscriptionContext ctx, CallExpression call, RegularArgument arg) { - if (isUnconditional(arg)) { + private static void checkNoneAssertion(SubscriptionContext ctx, CallExpression call, RegularArgument arg) { + if (isUnconditional(arg, ctx)) { ctx.addIssue(call, NONE_MESSAGE); } } - private void checkBooleanAssertion(SubscriptionContext ctx, RegularArgument arg) { - if (isUnconditional(arg)) { + private static void checkBooleanAssertion(SubscriptionContext ctx, RegularArgument arg) { + if (isUnconditional(arg, ctx)) { ctx.addIssue(arg, BOOLEAN_MESSAGE); } } @@ -132,7 +130,7 @@ private static void checkIsAssertion(SubscriptionContext ctx, CallExpression cal } } - private boolean isUnconditional(RegularArgument argument) { + private static boolean isUnconditional(RegularArgument argument, SubscriptionContext ctx) { Expression expression = argument.expression(); if (isConstant(expression)) { return true; @@ -151,7 +149,7 @@ private boolean isUnconditional(RegularArgument argument) { } if (expression.is(NAME)) { - Set valuesAtLocation = reachingDefinitionsAnalysis.valuesAtLocation(((Name) expression)); + Set valuesAtLocation = ctx.valuesAtLocation(((Name) expression)); if (valuesAtLocation.size() == 1) { return CheckUtils.isImmutableConstant(valuesAtLocation.iterator().next()); } diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/UseMonkeypatchFixtureCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/UseMonkeypatchFixtureCheck.java new file mode 100644 index 0000000000..f06fdd71ba --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/UseMonkeypatchFixtureCheck.java @@ -0,0 +1,219 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.AssignmentStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.DelStatement; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.ExpressionList; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.SubscriptionExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.CheckUtils; +import org.sonar.python.checks.utils.Expressions; +import org.sonar.python.checks.utils.UnittestUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S8997") +public class UseMonkeypatchFixtureCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Use the \"monkeypatch\" fixture for temporary modifications instead of manually modifying global state."; + private static final TypeMatcher ENVIRON_MATCHER = TypeMatchers.isType("os.environ"); + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN("pytest.fixture"); + private static final TypeMatcher SYS_PATH_LIST_MUTATION_CALL = + TypeMatchers.isFunctionOwnerSatisfying(TypeMatchers.isOrExtendsType("builtins.list")); + private static final Set PYTEST_LIFECYCLE_METHODS = Set.of( + "setUp", "tearDown", "setUpClass", "tearDownClass", + "setup_method", "teardown_method", "setup_class", "teardown_class", + "setup_module", "teardown_module"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.ASSIGNMENT_STMT, UseMonkeypatchFixtureCheck::checkAssignment); + context.registerSyntaxNodeConsumer(Tree.Kind.DEL_STMT, UseMonkeypatchFixtureCheck::checkDelete); + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, UseMonkeypatchFixtureCheck::checkCall); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkAssignment(SubscriptionContext ctx) { + FunctionDef testFunction = enclosingPytestTestFunction(ctx, ctx.syntaxNode()); + if (testFunction == null) { + return; + } + + AssignmentStatement assignmentStatement = (AssignmentStatement) ctx.syntaxNode(); + for (ExpressionList lhsExpressionList : assignmentStatement.lhsExpressions()) { + for (Expression lhsExpression : lhsExpressionList.expressions()) { + checkManualModification(ctx, Expressions.removeParentheses(lhsExpression), testFunction); + } + } + } + + private static void checkDelete(SubscriptionContext ctx) { + FunctionDef testFunction = enclosingPytestTestFunction(ctx, ctx.syntaxNode()); + if (testFunction == null) { + return; + } + + DelStatement delStatement = (DelStatement) ctx.syntaxNode(); + for (Expression expression : delStatement.expressions()) { + checkManualModification(ctx, Expressions.removeParentheses(expression), testFunction); + } + } + + private static void checkCall(SubscriptionContext ctx) { + FunctionDef testFunction = enclosingPytestTestFunction(ctx, ctx.syntaxNode()); + if (testFunction == null) { + return; + } + + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + if (!(callExpression.callee() instanceof QualifiedExpression methodCall)) { + return; + } + Expression receiver = Expressions.removeParentheses(methodCall.qualifier()); + if (!isSysPath(receiver, ctx) || !SYS_PATH_LIST_MUTATION_CALL.isTrueFor(callExpression.callee(), ctx)) { + return; + } + ctx.addIssue(callExpression, MESSAGE); + } + + private static void checkManualModification(SubscriptionContext ctx, Expression expression, FunctionDef testFunction) { + if (isOsEnvironSubscription(expression, ctx) + || isSysPathSubscription(expression, ctx) + || isManualModuleLevelAttributeAssignment(expression, testFunction)) { + ctx.addIssue(expression, MESSAGE); + } + } + + private static boolean isOsEnvironSubscription(Expression expression, SubscriptionContext ctx) { + return expression instanceof SubscriptionExpression subscriptionExpression + && ENVIRON_MATCHER.isTrueFor(subscriptionExpression.object(), ctx); + } + + private static boolean isSysPathSubscription(Expression expression, SubscriptionContext ctx) { + return expression instanceof SubscriptionExpression subscriptionExpression + && isSysPath(subscriptionExpression.object(), ctx); + } + + private static boolean isSysPath(Expression expression, SubscriptionContext ctx) { + return TreeUtils.fullyQualifiedNameFromExpression(expression) + .filter("sys.path"::equals) + .isPresent() + || (expression instanceof QualifiedExpression qualifiedExpression + && TypeMatchers.isType("sys").isTrueFor(qualifiedExpression.qualifier(), ctx) + && "path".equals(qualifiedExpression.name().name())); + } + + private static boolean isManualModuleLevelAttributeAssignment(Expression expression, FunctionDef testFunction) { + if (!(expression instanceof QualifiedExpression qualifiedExpression) + || CheckUtils.isSelf(qualifiedExpression.qualifier())) { + return false; + } + Expression base = leftmostExpression(expression); + if (base instanceof CallExpression) { + // Mutating attributes of a call result (mocks, helpers, factories) is not global state. + return false; + } + return !isLocallyBoundInTestFunction(base, testFunction); + } + + private static Expression leftmostExpression(Expression expression) { + Expression current = Expressions.removeParentheses(expression); + while (true) { + if (current instanceof QualifiedExpression qualifiedExpression) { + current = Expressions.removeParentheses(qualifiedExpression.qualifier()); + } else if (current instanceof SubscriptionExpression subscriptionExpression) { + current = Expressions.removeParentheses(subscriptionExpression.object()); + } else { + return current; + } + } + } + + private static boolean isLocallyBoundInTestFunction(Expression expression, FunctionDef testFunction) { + if (!(expression instanceof Name name)) { + return false; + } + SymbolV2 symbol = name.symbolV2(); + if (symbol == null) { + return false; + } + for (UsageV2 usage : symbol.usages()) { + if (!usage.isBindingUsage() || !isContainedIn(usage.tree(), testFunction)) { + continue; + } + return true; + } + return false; + } + + private static boolean isContainedIn(Tree tree, Tree ancestor) { + for (Tree current = tree; current != null; current = current.parent()) { + if (current == ancestor) { + return true; + } + } + return false; + } + + private static FunctionDef enclosingPytestTestFunction(SubscriptionContext ctx, Tree tree) { + FunctionDef functionDef = (FunctionDef) TreeUtils.firstAncestorOfKind(tree, Tree.Kind.FUNCDEF); + if (functionDef == null) { + return null; + } + if (isPytestFixture(functionDef, ctx) || isPytestLifecycleMethod(functionDef)) { + return null; + } + if (!UnittestUtils.isPytestStyleTestFunction(functionDef, ctx.pythonFile().fileName())) { + return null; + } + return functionDef; + } + + private static boolean isPytestFixture(FunctionDef functionDef, SubscriptionContext ctx) { + return functionDef.decorators().stream().anyMatch(decorator -> matchesPytestFixtureDecorator(decorator, ctx)); + } + + private static boolean matchesPytestFixtureDecorator(Decorator decorator, SubscriptionContext ctx) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + return PYTEST_FIXTURE_MATCHER.isTrueFor(callExpression.callee(), ctx); + } + return PYTEST_FIXTURE_MATCHER.isTrueFor(expression, ctx); + } + + private static boolean isPytestLifecycleMethod(FunctionDef functionDef) { + return PYTEST_LIFECYCLE_METHODS.contains(functionDef.name().name()); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/UseTmpPathInsteadOfFactoryCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/UseTmpPathInsteadOfFactoryCheck.java new file mode 100644 index 0000000000..ae4690b3ca --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/UseTmpPathInsteadOfFactoryCheck.java @@ -0,0 +1,80 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.Parameter; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.checks.utils.UnittestUtils; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S9002") +public class UseTmpPathInsteadOfFactoryCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Use \"tmp_path\" instead of \"tmp_path_factory\" in function-scoped tests."; + private static final String TMP_PATH_FACTORY = "tmp_path_factory"; + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN(UnittestUtils.PYTEST_FIXTURE_DECORATOR_FQN); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, UseTmpPathInsteadOfFactoryCheck::checkFunction); + } + + private static void checkFunction(SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) ctx.syntaxNode(); + if (!UnittestUtils.isPytestStyleTestFunction(functionDef, ctx.pythonFile().fileName())) { + return; + } + if (isPytestFixture(functionDef, ctx)) { + return; + } + + for (Parameter parameter : TreeUtils.nonTupleParameters(functionDef)) { + Name name = parameter.name(); + if (name != null && TMP_PATH_FACTORY.equals(name.name())) { + ctx.addIssue(name, MESSAGE); + } + } + } + + private static boolean isPytestFixture(FunctionDef functionDef, SubscriptionContext ctx) { + return functionDef.decorators().stream() + .anyMatch(decorator -> PYTEST_FIXTURE_MATCHER.isTrueFor(decoratorExpression(decorator), ctx)); + } + + private static Expression decoratorExpression(Decorator decorator) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + return callExpression.callee(); + } + return expression; + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/UselessPytestMarksCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/UselessPytestMarksCheck.java new file mode 100644 index 0000000000..9e312c33b8 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/UselessPytestMarksCheck.java @@ -0,0 +1,126 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import java.util.List; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.ArgList; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +@Rule(key = "S9074") +public class UselessPytestMarksCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE_MARK_ON_FIXTURE = "Remove this mark; it has no effect on fixtures."; + private static final String MESSAGE_EMPTY_USEFIXTURES = "Provide fixture names or remove this empty usefixtures decorator."; + + private static final TypeMatcher PYTEST_FIXTURE_MATCHER = TypeMatchers.withFQN("pytest.fixture"); + private static final TypeMatcher PYTEST_MARK_MATCHER = TypeMatchers.isType("pytest.mark"); + private static final TypeMatcher PYTEST_USEFIXTURES_MATCHER = TypeMatchers.isType("pytest.mark.usefixtures"); + private static final TypeMatcher KNOWN_PYTEST_MARK_MATCHER = TypeMatchers.any( + TypeMatchers.isType("pytest.mark.skip"), + TypeMatchers.isType("pytest.mark.xfail"), + TypeMatchers.isType("pytest.mark.parametrize"), + PYTEST_USEFIXTURES_MATCHER + ); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, ctx -> checkFunction(ctx, (FunctionDef) ctx.syntaxNode())); + context.registerSyntaxNodeConsumer(Tree.Kind.CLASSDEF, ctx -> checkClass(ctx, (ClassDef) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkFunction(SubscriptionContext ctx, FunctionDef functionDef) { + boolean isFixture = hasPytestFixtureDecorator(functionDef.decorators(), ctx); + for (Decorator decorator : functionDef.decorators()) { + checkDecorator(ctx, decorator, isFixture); + } + } + + private static void checkClass(SubscriptionContext ctx, ClassDef classDef) { + for (Decorator decorator : classDef.decorators()) { + checkDecorator(ctx, decorator, false); + } + } + + private static void checkDecorator(SubscriptionContext ctx, Decorator decorator, boolean isFixture) { + Expression markExpression = decoratorFunctionExpression(decorator); + if (!isPytestMark(markExpression, ctx)) { + return; + } + if (isFixture) { + ctx.addIssue(decorator, MESSAGE_MARK_ON_FIXTURE); + return; + } + if (isEmptyUsefixtures(decorator, markExpression, ctx)) { + ctx.addIssue(decorator, MESSAGE_EMPTY_USEFIXTURES); + } + } + + private static boolean hasPytestFixtureDecorator(List decorators, SubscriptionContext ctx) { + return decorators.stream() + .anyMatch(decorator -> PYTEST_FIXTURE_MATCHER.isTrueFor(decoratorFunctionExpression(decorator), ctx)); + } + + private static boolean isPytestMark(Expression expression, SubscriptionContext ctx) { + if (KNOWN_PYTEST_MARK_MATCHER.isTrueFor(expression, ctx)) { + return true; + } + if (expression instanceof QualifiedExpression qualifiedExpression) { + return PYTEST_MARK_MATCHER.isTrueFor(qualifiedExpression.qualifier(), ctx); + } + return false; + } + + private static boolean isEmptyUsefixtures(Decorator decorator, Expression markExpression, SubscriptionContext ctx) { + if (!PYTEST_USEFIXTURES_MATCHER.isTrueFor(markExpression, ctx)) { + return false; + } + return hasEmptyCallArguments(decorator); + } + + private static boolean hasEmptyCallArguments(Decorator decorator) { + Expression expression = decorator.expression(); + if (!(expression instanceof CallExpression callExpression)) { + return false; + } + ArgList argumentList = callExpression.argumentList(); + return argumentList == null || argumentList.arguments().isEmpty(); + } + + private static Expression decoratorFunctionExpression(Decorator decorator) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + return callExpression.callee(); + } + return expression; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/XfailNoReasonCheck.java b/python-checks/src/main/java/org/sonar/python/checks/tests/XfailNoReasonCheck.java new file mode 100644 index 0000000000..6fb44f96c4 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/XfailNoReasonCheck.java @@ -0,0 +1,95 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.tests; + +import javax.annotation.Nullable; +import org.sonar.check.Rule; +import org.sonar.plugins.python.api.PythonSubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.ArgList; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.StringLiteral; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +@Rule(key = "S9001") +public class XfailNoReasonCheck extends PythonSubscriptionCheck { + + private static final String MESSAGE = "Provide a reason for marking this test as expected to fail."; + + private static final TypeMatcher PYTEST_XFAIL_MATCHER = TypeMatchers.isType("pytest.mark.xfail"); + + @Override + public void initialize(Context context) { + context.registerSyntaxNodeConsumer(Tree.Kind.DECORATOR, ctx -> checkDecorator(ctx, (Decorator) ctx.syntaxNode())); + } + + @Override + public CheckScope scope() { + return CheckScope.ALL; + } + + private static void checkDecorator(SubscriptionContext ctx, Decorator decorator) { + Expression expression = decorator.expression(); + Expression xfailExpression = getXfailExpression(expression); + if (!PYTEST_XFAIL_MATCHER.isTrueFor(xfailExpression, ctx)) { + return; + } + + checkMissingReason(ctx, decorator, getArguments(decorator, expression)); + } + + private static Expression getXfailExpression(Expression expression) { + if (expression.is(Tree.Kind.CALL_EXPR)) { + return ((CallExpression) expression).callee(); + } + return expression; + } + + @Nullable + private static ArgList getArguments(Decorator decorator, Expression expression) { + if (expression.is(Tree.Kind.CALL_EXPR)) { + return ((CallExpression) expression).argumentList(); + } + return decorator.arguments(); + } + + private static void checkMissingReason(SubscriptionContext ctx, Tree issueTree, @Nullable ArgList args) { + if (args == null || args.arguments().isEmpty()) { + ctx.addIssue(issueTree, MESSAGE); + return; + } + + RegularArgument reasonArgument = TreeUtils.argumentByKeyword("reason", args.arguments()); + if (reasonArgument == null) { + ctx.addIssue(issueTree, MESSAGE); + return; + } + + if (reasonArgument.expression().is(Tree.Kind.STRING_LITERAL)) { + StringLiteral stringLiteral = (StringLiteral) reasonArgument.expression(); + if (stringLiteral.trimmedQuotesValue().isEmpty()) { + ctx.addIssue(issueTree, MESSAGE); + } + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/tests/package-info.java b/python-checks/src/main/java/org/sonar/python/checks/tests/package-info.java index 77f4d166c4..c5c4b57501 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/tests/package-info.java +++ b/python-checks/src/main/java/org/sonar/python/checks/tests/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/AssertpyUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/AssertpyUtils.java new file mode 100644 index 0000000000..6dccd5698d --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/AssertpyUtils.java @@ -0,0 +1,53 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.utils; + +import javax.annotation.Nullable; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +public final class AssertpyUtils { + + private static final TypeMatcher ASSERTPY_ASSERT_THAT_MATCHER = TypeMatchers.isType("assertpy.assert_that"); + + private AssertpyUtils() { + } + + public static boolean isAssertThatCall(CallExpression callExpression, SubscriptionContext ctx) { + return ASSERTPY_ASSERT_THAT_MATCHER.isTrueFor(callExpression.callee(), ctx); + } + + @Nullable + public static CallExpression originatingAssertThatCall(Expression expression, SubscriptionContext ctx) { + Expression qualifier = Expressions.removeParentheses(expression); + while (qualifier instanceof CallExpression callExpression) { + if (isAssertThatCall(callExpression, ctx)) { + return callExpression; + } + Expression callee = Expressions.removeParentheses(callExpression.callee()); + if (!(callee instanceof QualifiedExpression qualifiedExpression)) { + return null; + } + qualifier = Expressions.removeParentheses(qualifiedExpression.qualifier()); + } + return null; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/AwsLambdaChecksUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/AwsLambdaChecksUtils.java index 02e90bc950..69110aa648 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/utils/AwsLambdaChecksUtils.java +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/AwsLambdaChecksUtils.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/CheckUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/CheckUtils.java index f09c3f007a..cfae1602dd 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/utils/CheckUtils.java +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/CheckUtils.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -105,7 +105,10 @@ public static ClassDef getParentClassDef(Tree tree) { return null; } - public static boolean classHasInheritance(ClassDef classDef) { + public static boolean classHasInheritance(@Nullable ClassDef classDef) { + if (classDef == null) { + return false; + } ArgList argList = classDef.args(); if (argList == null) { return false; diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/DeadStoreUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/DeadStoreUtils.java index a1b5512c55..5cdc27a05d 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/utils/DeadStoreUtils.java +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/DeadStoreUtils.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/Expressions.java b/python-checks/src/main/java/org/sonar/python/checks/utils/Expressions.java index 80b92d1961..1989812984 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/utils/Expressions.java +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/Expressions.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -33,6 +33,7 @@ import org.sonar.plugins.python.api.tree.Argument; import org.sonar.plugins.python.api.tree.AssignmentStatement; import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ConditionalExpression; import org.sonar.plugins.python.api.tree.DictionaryLiteral; import org.sonar.plugins.python.api.tree.Expression; import org.sonar.plugins.python.api.tree.ExpressionList; @@ -42,6 +43,7 @@ import org.sonar.plugins.python.api.tree.NumericLiteral; import org.sonar.plugins.python.api.tree.ParenthesizedExpression; import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.SetLiteral; import org.sonar.plugins.python.api.tree.SliceExpression; import org.sonar.plugins.python.api.tree.StringElement; import org.sonar.plugins.python.api.tree.StringLiteral; @@ -173,6 +175,35 @@ public static Expression removeParentheses(Expression expression) { return res; } + public static boolean isBuiltinTypeCall(Expression expression) { + Expression unwrapped = removeParentheses(expression); + if (unwrapped instanceof CallExpression callExpression) { + Symbol calleeSymbol = callExpression.calleeSymbol(); + return calleeSymbol != null && "type".equals(calleeSymbol.fullyQualifiedName()); + } + return false; + } + + public static boolean isBuiltinTypeAssignment(Expression expression) { + Expression unwrappedExpression = removeParentheses(expression); + if (isBuiltinTypeCall(unwrappedExpression)) { + return true; + } + if (unwrappedExpression instanceof ConditionalExpression conditionalExpression) { + Expression trueExpression = conditionalExpression.trueExpression(); + Expression falseExpression = conditionalExpression.falseExpression(); + return isTypeValuedBranch(trueExpression) + && isTypeValuedBranch(falseExpression) + && (isBuiltinTypeAssignment(trueExpression) || isBuiltinTypeAssignment(falseExpression)); + } + return false; + } + + private static boolean isTypeValuedBranch(Expression branch) { + Expression unwrappedBranch = removeParentheses(branch); + return unwrappedBranch.is(Tree.Kind.NONE) || isBuiltinTypeAssignment(unwrappedBranch); + } + public static Optional singleAssignedNonNameValue(Name name) { Set visited = new HashSet<>(); Expression result = singleAssignedValue(name, visited); @@ -189,12 +220,19 @@ public static Optional ifNameGetSingleAssignedNonNameValue(Expressio return Optional.of(expression); } + /** + * Extracts the element expressions of a list, tuple, or set literal. Named for its original list/tuple-only + * scope; widened to also cover {@link SetLiteral} since a set is just as valid a literal-collection allowlist + * shape (e.g. {@code x in {"a", "b"}}) as a list or tuple. + */ public static List expressionsFromListOrTuple(Expression expression) { return TreeUtils.toOptionalInstanceOf(ListLiteral.class, expression) .map(ListLiteral::elements) .map(ExpressionList::expressions) .or(() -> TreeUtils.toOptionalInstanceOf(Tuple.class, expression) .map(Tuple::elements)) + .or(() -> TreeUtils.toOptionalInstanceOf(SetLiteral.class, expression) + .map(SetLiteral::elements)) .orElseGet(Collections::emptyList); } diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/FunctionParameterUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/FunctionParameterUtils.java new file mode 100644 index 0000000000..d78e3d3269 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/FunctionParameterUtils.java @@ -0,0 +1,84 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.utils; + +import java.util.HashSet; +import java.util.Optional; +import java.util.Set; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.types.v2.FunctionType; +import org.sonar.plugins.python.api.types.v2.ParameterV2; +import org.sonar.plugins.python.api.types.v2.PythonType; + +/** + * Utility class for extracting function parameter information. + */ +public final class FunctionParameterUtils { + + private FunctionParameterUtils() { + } + + /** + * Information about a function's parameters for path/URL parameter checks. + */ + public record FunctionParameterInfo(Set allParams, Set positionalOnlyParams, boolean hasVariadicKeyword) { + public static FunctionParameterInfo empty() { + return new FunctionParameterInfo(Set.of(), Set.of(), false); + } + + public boolean isMissingFromSignature(String param) { + return !allParams.contains(param) && !hasVariadicKeyword; + } + } + + public static FunctionParameterInfo extractFunctionParameters(FunctionDef functionDef) { + return getFunctionType(functionDef) + .map(FunctionParameterUtils::buildParameterInfo) + .orElse(FunctionParameterInfo.empty()); + } + + public static Optional getFunctionType(FunctionDef functionDef) { + PythonType functionType = functionDef.name().typeV2(); + if (functionType instanceof FunctionType funcType) { + return Optional.of(funcType); + } + return Optional.empty(); + } + + public static FunctionParameterInfo buildParameterInfo(FunctionType functionType) { + Set allParams = new HashSet<>(); + Set positionalOnlyParams = new HashSet<>(); + boolean hasVariadicKeyword = functionType.parameters().stream() + .anyMatch(param -> param.isVariadic() && param.isKeywordVariadic()); + + functionType.parameters().stream() + .filter(param -> !param.isVariadic()) + .forEach(param -> addParameter(param, allParams, positionalOnlyParams)); + + return new FunctionParameterInfo(allParams, positionalOnlyParams, hasVariadicKeyword); + } + + private static void addParameter(ParameterV2 param, Set allParams, Set positionalOnlyParams) { + String paramName = param.name(); + if (paramName != null) { + allParams.add(paramName); + if (param.isPositionalOnly()) { + positionalOnlyParams.add(paramName); + } + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/GeneratedFileUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/GeneratedFileUtils.java new file mode 100644 index 0000000000..1a043d8516 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/GeneratedFileUtils.java @@ -0,0 +1,48 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.utils; + +import org.sonar.plugins.python.api.PythonFile; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.python.checks.django.DjangoUtils; + +public final class GeneratedFileUtils { + private static final String PROTOBUF_GENERATED_MARKER = "# Generated by the protocol buffer compiler."; + private static final String GRPC_GENERATED_MARKER = "# Generated by the gRPC Python protocol compiler plugin."; + + private GeneratedFileUtils() { + } + + public static boolean isGeneratedFileForReadabilityRules(PythonFile pythonFile, Tree tree) { + return DjangoUtils.isDjangoGeneratedMigrationFile(pythonFile, tree) || isProtobufGeneratedFile(pythonFile); + } + + private static boolean isProtobufGeneratedFile(PythonFile pythonFile) { + String path = pythonFile.uri().getPath(); + if (path == null) { + return false; + } + + String normalizedPath = path.replace('\\', '/'); + if (!normalizedPath.endsWith("_pb2.py") && !normalizedPath.endsWith("_pb2_grpc.py")) { + return false; + } + + return pythonFile.content().contains(PROTOBUF_GENERATED_MARKER) + || pythonFile.content().contains(GRPC_GENERATED_MARKER); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/GraphQLUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/GraphQLUtils.java index 30fbcebac7..bbb880d4ee 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/utils/GraphQLUtils.java +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/GraphQLUtils.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/ImportedNamesCollector.java b/python-checks/src/main/java/org/sonar/python/checks/utils/ImportedNamesCollector.java index 70743b5627..b68322a8ca 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/utils/ImportedNamesCollector.java +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/ImportedNamesCollector.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/IsComprehensionTransformedChecker.java b/python-checks/src/main/java/org/sonar/python/checks/utils/IsComprehensionTransformedChecker.java index 223ede5edd..18d296a4c3 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/utils/IsComprehensionTransformedChecker.java +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/IsComprehensionTransformedChecker.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/MarimoUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/MarimoUtils.java new file mode 100644 index 0000000000..d92962e9d7 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/MarimoUtils.java @@ -0,0 +1,73 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.utils; + +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.tree.Tree.Kind; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +public class MarimoUtils { + + private static final TypeMatcher APP_CELL_MATCHER = TypeMatchers.isType("marimo.App.cell"); + private static final TypeMatcher APP_FUNCTION_MATCHER = TypeMatchers.isType("marimo.App.function"); + + private MarimoUtils() { + } + + public static boolean isTreeInMarimoDecoratedFunction(Tree tree, SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) TreeUtils.firstAncestorOfKind(tree, Kind.FUNCDEF); + if (functionDef == null) { + return false; + } + return functionDef.decorators().stream().anyMatch(decorator -> isAppCellDecorator(decorator, ctx)); + } + + public static boolean isTreeInMarimoCell(Tree tree, SubscriptionContext ctx) { + FunctionDef functionDef = (FunctionDef) TreeUtils.firstAncestorOfKind(tree, Kind.FUNCDEF); + if (functionDef == null) { + return false; + } + return functionDef.decorators().stream().anyMatch(d -> isAppCell(d, ctx)); + } + + private static boolean isAppCell(Decorator decorator, SubscriptionContext ctx) { + return APP_CELL_MATCHER.isTrueFor(resolveDecoratorExpression(decorator), ctx); + } + + private static boolean isAppFunction(Decorator decorator, SubscriptionContext ctx) { + return APP_FUNCTION_MATCHER.isTrueFor(resolveDecoratorExpression(decorator), ctx); + } + + private static boolean isAppCellDecorator(Decorator decorator, SubscriptionContext ctx) { + return isAppCell(decorator, ctx) || isAppFunction(decorator, ctx); + } + + private static Expression resolveDecoratorExpression(Decorator decorator) { + Expression expr = decorator.expression(); + if (expr instanceof CallExpression callExpr) { + return callExpr.callee(); + } + return expr; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/MockPatchUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/MockPatchUtils.java new file mode 100644 index 0000000000..e2e96b0b91 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/MockPatchUtils.java @@ -0,0 +1,94 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.utils; + +import java.util.Set; +import java.util.stream.Stream; +import javax.annotation.Nullable; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.v2.SymbolV2; +import org.sonar.plugins.python.api.symbols.v2.UsageV2; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; + +public final class MockPatchUtils { + + private static final String PATCH_METHOD = "patch"; + private static final String OBJECT_METHOD = "object"; + + /** + * The {@code mocker} fixtures come from pytest-mock, which has no typeshed stubs, hence the name based detection. + */ + private static final Set MOCKER_FIXTURE_NAMES = Set.of( + "mocker", "class_mocker", "module_mocker", "package_mocker", "session_mocker"); + + private static final TypeMatcher PATCHER_MATCHER = TypeMatchers.isObjectSatisfying( + TypeMatchers.any( + TypeMatchers.isType("unittest.mock._patcher"), + TypeMatchers.isType("mock.mock._patcher"))); + + private MockPatchUtils() { + } + + /** + * @return the position of the {@code new} parameter for the patching call, or {@code -1} when the callee is not a patching call. + */ + public static int newArgumentPosition(Expression callee, SubscriptionContext ctx) { + if (PATCHER_MATCHER.isTrueFor(callee, ctx)) { + return 1; + } + if (!(callee instanceof QualifiedExpression qualifiedExpression)) { + return -1; + } + Expression qualifier = Expressions.removeParentheses(qualifiedExpression.qualifier()); + String memberName = qualifiedExpression.name().name(); + if (OBJECT_METHOD.equals(memberName) && (PATCHER_MATCHER.isTrueFor(qualifier, ctx) || isMockerPatch(qualifier))) { + return 2; + } + if (PATCH_METHOD.equals(memberName) && isMockerFixture(qualifier)) { + return 1; + } + return -1; + } + + private static boolean isMockerPatch(Expression expression) { + return expression instanceof QualifiedExpression qualifiedExpression + && PATCH_METHOD.equals(qualifiedExpression.name().name()) + && isMockerFixture(Expressions.removeParentheses(qualifiedExpression.qualifier())); + } + + private static boolean isMockerFixture(Expression expression) { + Expression expr = Expressions.removeParentheses(expression); + if (expr instanceof Name name) { + return MOCKER_FIXTURE_NAMES.contains(name.name()) && isFunctionParameter(name.symbolV2()); + } + // Class-based suites often store the fixture on self in setup_method; match by attribute name only. + return expr instanceof QualifiedExpression qualifiedExpression + && Expressions.removeParentheses(qualifiedExpression.qualifier()) instanceof Name qualifier + && "self".equals(qualifier.name()) + && MOCKER_FIXTURE_NAMES.contains(qualifiedExpression.name().name()); + } + + private static boolean isFunctionParameter(@Nullable SymbolV2 symbol) { + return Stream.ofNullable(symbol) + .flatMap(s -> s.usages().stream()) + .anyMatch(usage -> usage.kind() == UsageV2.Kind.PARAMETER); + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/SingleInvocationUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/SingleInvocationUtils.java new file mode 100644 index 0000000000..4876d9fc9d --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/SingleInvocationUtils.java @@ -0,0 +1,170 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.utils; + +import java.util.ArrayList; +import java.util.List; +import org.sonar.plugins.python.api.IssueLocation; +import org.sonar.plugins.python.api.PythonCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.tree.BaseTreeVisitor; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.LambdaExpression; +import org.sonar.plugins.python.api.tree.Name; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +/** + * Shared helpers for single-invocation assertion checks (e.g. S5778, S9088): + * collecting possibly-raising/warning calls inside {@code with} / lambda bodies + * and reporting secondary locations on each unsafe invocation. + */ +public final class SingleInvocationUtils { + + /** + * Calls that are almost never the exception/warning under test when nested inside + * {@code pytest.raises} / {@code assertRaises} / {@code pytest.warns}. + * Treating them as safe avoids noisy FPs on common setup helpers. + */ + private static final TypeMatcher ALWAYS_SAFE_CALL_MATCHER = TypeMatchers.any( + TypeMatchers.isType("builtins.str"), + TypeMatchers.isType("builtins.bytes"), + TypeMatchers.isType("builtins.bytearray"), + TypeMatchers.isType("builtins.repr"), + TypeMatchers.isType("builtins.ascii"), + TypeMatchers.isType("builtins.format"), + TypeMatchers.isType("builtins.bool"), + TypeMatchers.isType("builtins.int"), + TypeMatchers.isType("builtins.float"), + TypeMatchers.isType("builtins.complex"), + TypeMatchers.isType("builtins.memoryview"), + TypeMatchers.isType("builtins.list"), + TypeMatchers.isType("builtins.tuple"), + TypeMatchers.isType("builtins.dict"), + TypeMatchers.isType("builtins.print"), + TypeMatchers.isType("builtins.len"), + TypeMatchers.isType("builtins.abs"), + TypeMatchers.isType("builtins.round"), + TypeMatchers.isType("builtins.id"), + TypeMatchers.isType("builtins.hash"), + TypeMatchers.isType("builtins.hex"), + TypeMatchers.isType("builtins.oct"), + TypeMatchers.isType("builtins.bin"), + TypeMatchers.isType("builtins.ord"), + TypeMatchers.isType("builtins.chr"), + TypeMatchers.isType("builtins.range"), + TypeMatchers.isType("builtins.enumerate"), + TypeMatchers.isType("builtins.zip"), + TypeMatchers.isType("builtins.reversed"), + TypeMatchers.isType("builtins.sorted"), + TypeMatchers.isType("builtins.slice"), + TypeMatchers.isType("builtins.callable"), + TypeMatchers.isType("pathlib.Path"), + TypeMatchers.isType("pathlib.PurePath"), + TypeMatchers.isType("pathlib.PosixPath"), + TypeMatchers.isType("pathlib.WindowsPath"), + TypeMatchers.isType("pathlib.PurePosixPath"), + TypeMatchers.isType("pathlib.PureWindowsPath"), + TypeMatchers.isType("uuid.UUID"), + TypeMatchers.isType("uuid.uuid1"), + TypeMatchers.isType("uuid.uuid3"), + TypeMatchers.isType("uuid.uuid4"), + TypeMatchers.isType("uuid.uuid5"), + TypeMatchers.isType("uuid.uuid6"), + TypeMatchers.isType("uuid.uuid7"), + TypeMatchers.isType("uuid.uuid8"), + TypeMatchers.isType("copy.copy"), + TypeMatchers.isType("copy.deepcopy"), + // NumPy/SciPy lack stubs → UnresolvedImportType; withFQNPrefix covers factories/helpers + // (zeros, random, copy, legendre, …) used as nested setup in exception/warning assertions. + TypeMatchers.withFQNPrefix("numpy."), + TypeMatchers.withFQNPrefix("scipy.")); + + /** + * Constructors that are safe only without arguments (with args they commonly raise TypeError + * or can behave unexpectedly). + */ + private static final TypeMatcher EMPTY_ARGS_SAFE_CALL_MATCHER = TypeMatchers.any( + TypeMatchers.isType("builtins.set"), + TypeMatchers.isType("builtins.frozenset"), + TypeMatchers.isType("builtins.object")); + + private SingleInvocationUtils() { + } + + public static List unsafeInvocations(Tree tree, SubscriptionContext ctx) { + var visitor = new InvocationCollector(ctx); + tree.accept(visitor); + return visitor.invocations.stream() + .sorted(TreeUtils.getTreeByPositionComparator()) + .toList(); + } + + public static void reportIfMultipleInvocations(PythonCheck.PreciseIssue issue, List invocations, + String secondaryMessage) { + invocations.forEach(invocation -> issue.secondary(invocationLocation(invocation, secondaryMessage))); + } + + private static IssueLocation invocationLocation(CallExpression invocation, String message) { + if (invocation.callee() instanceof QualifiedExpression qualifiedExpression) { + return IssueLocation.preciseLocation(qualifiedExpression.name().firstToken(), invocation.rightPar(), message); + } + if (invocation.callee() instanceof Name calleeName) { + return IssueLocation.preciseLocation(calleeName.firstToken(), invocation.rightPar(), message); + } + return IssueLocation.preciseLocation(invocation, message); + } + + private static class InvocationCollector extends BaseTreeVisitor { + private final SubscriptionContext ctx; + private final List invocations = new ArrayList<>(); + + private InvocationCollector(SubscriptionContext ctx) { + this.ctx = ctx; + } + + @Override + public void visitCallExpression(CallExpression callExpression) { + if (!isSafeCall(callExpression)) { + invocations.add(callExpression); + } + super.visitCallExpression(callExpression); + } + + @Override + public void visitLambda(LambdaExpression lambdaExpression) { + // Nested lambdas define deferred execution and should not contribute calls here. + } + + @Override + public void visitFunctionDef(FunctionDef functionDef) { + // Nested function bodies are not executed when merely defined. + } + + private boolean isSafeCall(CallExpression callExpression) { + if (ALWAYS_SAFE_CALL_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return true; + } + return EMPTY_ARGS_SAFE_CALL_MATCHER.isTrueFor(callExpression.callee(), ctx) + && callExpression.arguments().isEmpty(); + } + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/StringLiteralValuesCollector.java b/python-checks/src/main/java/org/sonar/python/checks/utils/StringLiteralValuesCollector.java index f7e959a51c..5bfaa4d888 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/utils/StringLiteralValuesCollector.java +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/StringLiteralValuesCollector.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/UnittestUtils.java b/python-checks/src/main/java/org/sonar/python/checks/utils/UnittestUtils.java new file mode 100644 index 0000000000..ad0673c2c6 --- /dev/null +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/UnittestUtils.java @@ -0,0 +1,368 @@ +/* + * SonarQube Python Plugin + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.python.checks.utils; + +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.function.BiConsumer; +import javax.annotation.Nullable; +import org.sonar.plugins.python.api.SubscriptionCheck; +import org.sonar.plugins.python.api.SubscriptionContext; +import org.sonar.plugins.python.api.symbols.Symbol; +import org.sonar.plugins.python.api.tree.Argument; +import org.sonar.plugins.python.api.tree.AssertStatement; +import org.sonar.plugins.python.api.tree.CallExpression; +import org.sonar.plugins.python.api.tree.ClassDef; +import org.sonar.plugins.python.api.tree.Decorator; +import org.sonar.plugins.python.api.tree.Expression; +import org.sonar.plugins.python.api.tree.FunctionDef; +import org.sonar.plugins.python.api.tree.QualifiedExpression; +import org.sonar.plugins.python.api.tree.RegularArgument; +import org.sonar.plugins.python.api.tree.Tree; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatcher; +import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers; +import org.sonar.python.tree.TreeUtils; + +public class UnittestUtils { + private static final Set PYTEST_LIFECYCLE_METHODS = Set.of( + "setUp", "tearDown", "setUpClass", "tearDownClass", + "setup_method", "teardown_method", "setup_class", "teardown_class", "setup_module", "teardown_module"); + public static final String PYTEST_FIXTURE_DECORATOR_FQN = "pytest.fixture"; + private static final String UNITTEST_TEST_CASE_FQN_PREFIX = "unittest.case.TestCase."; + private static final String PYTEST_EXPECTED_EXCEPTION = "expected_exception"; + private static final String PYTEST_EXPECTED_WARNING = "expected_warning"; + private static final String PYTEST_MATCH = "match"; + private static final String UNITTEST_EXCEPTION = "exception"; + private static final TypeMatcher PYTEST_RAISES_MATCHER = TypeMatchers.withFQN("pytest.raises"); + private static final TypeMatcher PYTEST_WARNS_MATCHER = TypeMatchers.withFQN("pytest.warns"); + public static final String ASSERT_RAISES_REGEXP = "assertRaisesRegexp"; + public static final String ASSERT_RAISES_REGEX = "assertRaisesRegex"; + private static final TypeMatcher UNITTEST_ASSERT_RAISES_MATCHER = TypeMatchers.any( + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + "assertRaises"), + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + ASSERT_RAISES_REGEX), + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + ASSERT_RAISES_REGEXP) + ); + private static final TypeMatcher UNITTEST_ASSERT_RAISES_WITH_MESSAGE_CHECK_MATCHER = TypeMatchers.any( + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + ASSERT_RAISES_REGEX), + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + ASSERT_RAISES_REGEXP) + ); + public static final TypeMatcher UNITTEST_EQUALITY_ASSERTION_MATCHER = TypeMatchers.any( + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + "assertEqual"), + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + "assertNotEqual"), + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + "assertAlmostEqual"), + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + "assertNotAlmostEqual")); + public static final TypeMatcher UNITTEST_IDENTITY_ASSERTION_MATCHER = TypeMatchers.any( + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + "assertIs"), + TypeMatchers.isType(UNITTEST_TEST_CASE_FQN_PREFIX + "assertIsNot")); + public static final TypeMatcher PYTEST_APPROX_MATCHER = TypeMatchers.isType("pytest.approx"); + private static final TypeMatcher PYTEST_PARAMETRIZE_MATCHER = TypeMatchers.isType("pytest.mark.parametrize"); + public static final TypeMatcher ASSERTPY_IS_EQUAL_TO_MATCHER = TypeMatchers.isType("assertpy.AssertionBuilder.is_equal_to"); + public static final TypeMatcher ASSERTPY_EQUALITY_ASSERTION_MATCHER = TypeMatchers.any( + TypeMatchers.isType("assertpy.AssertionBuilder.is_equal_to"), + TypeMatchers.isType("assertpy.AssertionBuilder.is_not_equal_to")); + + public record AssertionParameterNames(String leftKeyword, String rightKeyword) { + } + + public record AssertionArguments(Expression actual, Expression expected) { + } + + public record AssertionFrameworkHandlers( + BiConsumer unittest, + BiConsumer assertpy, + BiConsumer pytest) { + } + + private UnittestUtils() { + + } + + public static final Set RUN_METHODS = Set.of("setUp", "tearDown", "setUpClass", "tearDownClass", "run", "skipTest", + "subTest", "debug", "asyncSetUp", "asyncTearDown"); + + public static final Set RAISE_METHODS = Set.of("assertRaises", ASSERT_RAISES_REGEXP, ASSERT_RAISES_REGEX); + + public static final Set ASSERTIONS_METHODS = Set.of("assertEqual", "assertNotEqual", "assertTrue", "assertFalse", "assertIs", + "assertIsNot", "assertIsNone", "assertIsNotNone", "assertIn", "assertNotIn", "assertIsInstance", "assertNotIsInstance", + "assertAlmostEqual", "assertNotAlmostEqual", "assertGreater", "assertGreaterEqual", "assertLess", "assertLessEqual", + "assertRegexpMatches", "assertNotRegexpMatches", "assertItemsEqual", "assertDictContainsSubset", "assertMultiLineEqual", + "assertSequenceEqual", "assertListEqual", "assertTupleEqual", "assertSetEqual", "assertDictEqual", "assertWarns", "assertWarnsRegex", + "assertLogs", "assertNoLogs", "assertRegex", "assertNotRegex", "assertCountEqual"); + + public static final Set UTIL_METHODS = Set.of("addTypeEqualityFunc", "fail", "failureException", "longMessage", "maxDiff"); + + public static final Set GATHER_INFO_METHODS = Set.of("countTestCases", "defaultTestResult", "id", "shortDescription", "addCleanup", + "doCleanups", "addClassCleanup", "doClassCleanups"); + + private static final Set ALL_METHODS = new HashSet<>(); + private static final Set ALL_ASSERT_METHODS = new HashSet<>(); + + static { + ALL_METHODS.addAll(RUN_METHODS); + ALL_METHODS.addAll(UTIL_METHODS); + ALL_METHODS.addAll(GATHER_INFO_METHODS); + ALL_METHODS.addAll(ASSERTIONS_METHODS); + ALL_METHODS.addAll(RAISE_METHODS); + ALL_ASSERT_METHODS.addAll(ASSERTIONS_METHODS); + ALL_ASSERT_METHODS.addAll(RAISE_METHODS); + } + + public static Set allMethods() { + return Collections.unmodifiableSet(ALL_METHODS); + } + + public static Set allAssertMethods() { + return Collections.unmodifiableSet(ALL_ASSERT_METHODS); + } + + public static boolean isTestMethodName(String name) { + return name.startsWith("test"); + } + + public static boolean isTestClassName(String name) { + return name.startsWith("Test"); + } + + /** + * Broader than {@link #isTestClassName}: also accepts celery-style {@code test_*}, + * unittest-style {@code *Test}/{@code *Tests}/{@code *TestCase} names. + */ + public static boolean isLikelyTestClassName(String name) { + return isTestClassName(name) + || name.startsWith("test") + || name.endsWith("Test") + || name.endsWith("Tests") + || name.endsWith("TestCase"); + } + + public static boolean isPytestFileName(String fileName) { + return fileName.startsWith("test_") || fileName.endsWith("_test.py"); + } + + public static boolean hasConstructor(ClassDef classDef) { + return classDef.body().statements().stream() + .filter(FunctionDef.class::isInstance) + .map(FunctionDef.class::cast) + .anyMatch(functionDef -> { + String name = functionDef.name().name(); + return "__init__".equals(name) || "__new__".equals(name); + }); + } + + public static boolean hasPytestLifecycleMethods(ClassDef classDef) { + return classDef.body().statements().stream() + .filter(FunctionDef.class::isInstance) + .map(FunctionDef.class::cast) + .anyMatch(functionDef -> + PYTEST_LIFECYCLE_METHODS.contains(functionDef.name().name()) + || functionDef.decorators().stream() + .anyMatch(UnittestUtils::isPytestFixtureDecorator)); + } + + public static boolean isPytestStyleTestClass(ClassDef classDef, String fileName) { + return isPytestFileName(fileName) + && isTestClassName(classDef.name().name()) + && !hasConstructor(classDef) + && hasPytestLifecycleMethods(classDef); + } + + public static boolean isPytestStyleTestFunction(FunctionDef functionDef, String fileName) { + if (!isPytestFileName(fileName) || !isTestMethodName(functionDef.name().name())) { + return false; + } + ClassDef parentClass = directlyEnclosingClass(functionDef); + return parentClass == null || isTestClassName(parentClass.name().name()); + } + + /** + * Like {@link #isPytestStyleTestFunction} but accepts a broader set of test class names + * (see {@link #isLikelyTestClassName}). Nested helpers inside non-test classes are excluded. + */ + public static boolean isCollectedPytestTestFunction(FunctionDef functionDef, String fileName) { + if (!isPytestFileName(fileName) || !isTestMethodName(functionDef.name().name())) { + return false; + } + ClassDef parentClass = directlyEnclosingClass(functionDef); + return parentClass == null || isLikelyTestClassName(parentClass.name().name()); + } + + public static boolean isPytestRaises(CallExpression callExpression, SubscriptionContext ctx) { + return PYTEST_RAISES_MATCHER.isTrueFor(callExpression.callee(), ctx); + } + + public static boolean isPytestWarns(CallExpression callExpression, SubscriptionContext ctx) { + return PYTEST_WARNS_MATCHER.isTrueFor(callExpression.callee(), ctx); + } + + @Nullable + public static RegularArgument pytestExpectedExceptionArgument(CallExpression callExpression) { + return TreeUtils.nthArgumentOrKeyword(0, PYTEST_EXPECTED_EXCEPTION, callExpression.arguments()); + } + + @Nullable + public static RegularArgument pytestExpectedWarningArgument(CallExpression callExpression) { + return TreeUtils.nthArgumentOrKeyword(0, PYTEST_EXPECTED_WARNING, callExpression.arguments()); + } + + @Nullable + public static RegularArgument pytestMatchArgument(CallExpression callExpression) { + return TreeUtils.argumentByKeyword(PYTEST_MATCH, callExpression.arguments()); + } + + /** + * Extracts the {@code argvalues} expression of a {@code @pytest.mark.parametrize(...)} decorator, + * or {@code null} if the decorator is not a parametrize call or has no {@code argvalues}. + */ + @Nullable + public static Expression parametrizeArgvaluesExpression(Decorator decorator, SubscriptionContext ctx) { + Expression expression = decorator.expression(); + if (!(expression instanceof CallExpression callExpression) || !PYTEST_PARAMETRIZE_MATCHER.isTrueFor(callExpression.callee(), ctx)) { + return null; + } + RegularArgument valuesArgument = TreeUtils.nthArgumentOrKeyword(1, "argvalues", callExpression.arguments()); + return valuesArgument == null ? null : Expressions.removeParentheses(valuesArgument.expression()); + } + + public static boolean isUnittestAssertRaises(CallExpression callExpression, SubscriptionContext ctx) { + return UNITTEST_ASSERT_RAISES_MATCHER.isTrueFor(callExpression.callee(), ctx); + } + + public static boolean hasUnittestAssertRaisesMessageCheck(CallExpression callExpression, SubscriptionContext ctx) { + return UNITTEST_ASSERT_RAISES_WITH_MESSAGE_CHECK_MATCHER.isTrueFor(callExpression.callee(), ctx); + } + + @Nullable + public static RegularArgument unittestExceptionArgument(CallExpression callExpression) { + return TreeUtils.nthArgumentOrKeyword(0, UNITTEST_EXCEPTION, callExpression.arguments()); + } + + private static boolean isPytestFixtureDecorator(Decorator decorator) { + Expression expression = decorator.expression(); + if (expression instanceof CallExpression callExpression) { + expression = callExpression.callee(); + } + return TreeUtils.getSymbolFromTree(expression) + .map(Symbol::fullyQualifiedName) + .filter(PYTEST_FIXTURE_DECORATOR_FQN::equals) + .isPresent(); + } + + public static boolean isUnittestTestCaseClass(ClassDef classDef) { + return TreeUtils.getParentClassesFQN(classDef).stream().anyMatch(parentClass -> parentClass.contains("unittest") && parentClass.contains("TestCase")); + } + + public static boolean isWithinUnittestTestCase(Tree tree) { + ClassDef classDef = (ClassDef) TreeUtils.firstAncestorOfKind(tree, Tree.Kind.CLASSDEF); + return classDef != null && isUnittestTestCaseClass(classDef); + } + + public static boolean isPytestStyleTestFunction(SubscriptionContext ctx, Tree tree) { + FunctionDef functionDef = (FunctionDef) TreeUtils.firstAncestorOfKind(tree, Tree.Kind.FUNCDEF); + return functionDef != null && isPytestStyleTestFunction(functionDef, ctx.pythonFile().fileName()); + } + + public static boolean isSupportedTestFunction(SubscriptionContext ctx, Tree tree) { + FunctionDef functionDef = (FunctionDef) TreeUtils.firstAncestorOfKind(tree, Tree.Kind.FUNCDEF); + return functionDef != null && (isWithinUnittestTestCase(functionDef) || isPytestStyleTestFunction(functionDef, ctx.pythonFile().fileName())); + } + + public static void registerAssertionSyntaxNodeConsumers(SubscriptionCheck.Context context, AssertionFrameworkHandlers handlers) { + context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> { + CallExpression callExpression = (CallExpression) ctx.syntaxNode(); + handlers.unittest().accept(ctx, callExpression); + handlers.assertpy().accept(ctx, callExpression); + }); + context.registerSyntaxNodeConsumer(Tree.Kind.ASSERT_STMT, ctx -> handlers.pytest().accept(ctx, (AssertStatement) ctx.syntaxNode())); + } + + @Nullable + public static AssertionArguments unittestAssertionArguments(CallExpression callExpression, SubscriptionContext ctx) { + if (!isWithinUnittestTestCase(callExpression)) { + return null; + } + if (!(Expressions.removeParentheses(callExpression.callee()) instanceof QualifiedExpression qualifiedExpression) + || !CheckUtils.isSelf(qualifiedExpression.qualifier())) { + return null; + } + + AssertionParameterNames parameterNames = unittestAssertionParameterNames(callExpression.callee(), ctx); + if (parameterNames == null) { + return null; + } + + List arguments = callExpression.arguments(); + RegularArgument firstArg = TreeUtils.nthArgumentOrKeyword(0, parameterNames.leftKeyword(), arguments); + RegularArgument secondArg = TreeUtils.nthArgumentOrKeyword(1, parameterNames.rightKeyword(), arguments); + if (firstArg == null || secondArg == null) { + return null; + } + + return new AssertionArguments(firstArg.expression(), secondArg.expression()); + } + + @Nullable + public static AssertionArguments assertpyAssertionArguments(CallExpression callExpression, SubscriptionContext ctx, TypeMatcher equalityMatcher) { + if (!isSupportedTestFunction(ctx, callExpression)) { + return null; + } + if (!(Expressions.removeParentheses(callExpression.callee()) instanceof QualifiedExpression qualifiedExpression) + || !equalityMatcher.isTrueFor(callExpression.callee(), ctx)) { + return null; + } + + CallExpression assertThatCall = AssertpyUtils.originatingAssertThatCall(qualifiedExpression.qualifier(), ctx); + if (assertThatCall == null) { + return null; + } + + RegularArgument actualArg = TreeUtils.nthArgumentOrKeyword(0, "val", assertThatCall.arguments()); + RegularArgument expectedArg = TreeUtils.nthArgumentOrKeyword(0, "other", callExpression.arguments()); + if (actualArg == null || expectedArg == null) { + return null; + } + + return new AssertionArguments(actualArg.expression(), expectedArg.expression()); + } + + @Nullable + public static AssertionParameterNames unittestAssertionParameterNames(Expression callee, SubscriptionContext ctx) { + if (UNITTEST_EQUALITY_ASSERTION_MATCHER.isTrueFor(callee, ctx)) { + return new AssertionParameterNames("first", "second"); + } + if (UNITTEST_IDENTITY_ASSERTION_MATCHER.isTrueFor(callee, ctx)) { + return new AssertionParameterNames("expr1", "expr2"); + } + return null; + } + + @Nullable + private static ClassDef directlyEnclosingClass(Tree tree) { + Tree current = tree.parent(); + while (current != null) { + if (current.is(Tree.Kind.CLASSDEF)) { + return (ClassDef) current; + } + if (current.is(Tree.Kind.FUNCDEF, Tree.Kind.LAMBDA)) { + return null; + } + current = current.parent(); + } + return null; + } +} diff --git a/python-checks/src/main/java/org/sonar/python/checks/utils/package-info.java b/python-checks/src/main/java/org/sonar/python/checks/utils/package-info.java index d3e954bfac..ed42e1cd6c 100644 --- a/python-checks/src/main/java/org/sonar/python/checks/utils/package-info.java +++ b/python-checks/src/main/java/org/sonar/python/checks/utils/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/java/org/sonar/python/package-info.java b/python-checks/src/main/java/org/sonar/python/package-info.java index dfd27de734..fbad990d67 100644 --- a/python-checks/src/main/java/org/sonar/python/package-info.java +++ b/python-checks/src/main/java/org/sonar/python/package-info.java @@ -1,10 +1,10 @@ /* * SonarQube Python Plugin - * Copyright (C) 2011-2025 SonarSource Sàrl + * Copyright (C) SonarSource Sàrl * mailto:info AT sonarsource DOT com * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA. + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1313.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1313.html index bf034f2e12..39606667ed 100644 --- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1313.html +++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1313.html @@ -1,44 +1,23 @@ -

Hardcoding IP addresses is security-sensitive. It has led in the past to the following vulnerabilities:

+

IP addresses hardcoded in source code couple the application to a specific infrastructure configuration. Today’s services have an ever-changing +architecture due to their scaling and redundancy needs. When an IP address changes, every hardcoded occurrence must be found and updated, which has an +impact on development, delivery, and deployment:

    -
  • CVE-2006-5901
    • -
  • CVE-2005-3725
    • +
  • Developers must fix the code every time the address changes, instead of having an operations team update a configuration file.
    • +
  • It leads to using the same address in every environment (dev, staging, QA, production).
-

Today’s services have an ever-changing architecture due to their scaling and redundancy needs. It is a mistake to think that a service will always -have the same IP address. When it does change, the hardcoded IP will have to be modified too. This will have an impact on the product development, -delivery, and deployment:

-
    -
  • The developers will have to do a rapid fix every time this happens, instead of having an operation team change a configuration file.
    • -
  • It misleads to use the same address in every environment (dev, sys, qa, prod).
    • -
-

Last but not least it has an effect on application security. Attackers might be able to decompile the code and thereby discover a potentially -sensitive address. They can perform a Denial of Service attack on the service, try to get access to the system, or try to spoof the IP address to -bypass security checks. Such attacks can always be possible, but in the case of a hardcoded IP address solving the issue will take more time, which -will increase an attack’s impact.

-

Ask Yourself Whether

-

The disclosed IP address is sensitive, e.g.:

-
    -
  • Can give information to an attacker about the network topology.
    • -
  • It’s a personal (assigned to an identifiable person) IP address.
    • -
-

There is a risk if you answered yes to any of these questions.

-

Recommended Secure Coding Practices

-

Don’t hard-code the IP address in the source code, instead make it configurable with environment variables, configuration files, or a similar -approach. Alternatively, if confidentially is not required a domain name can be used since it allows to change the destination quickly without having -to rebuild the software.

-

Sensitive Code Example

-
-ip = '192.168.12.42'
-sock = socket.socket()
-sock.bind((ip, 9090))
-
-

Compliant Solution

-
-ip = config.get(section, ipAddress)
-sock = socket.socket()
-sock.bind((ip, 9090))
-
-

Exceptions

-

No issue is reported for the following cases because they are not considered sensitive:

+

Why is this an issue?

+

Hardcoding an IP address embeds infrastructure configuration directly into the application. This means any change to the network environment—such +as moving a service to a different host or scaling horizontally—requires a code modification and a full redeployment. Unlike a domain name, a +hardcoded address also makes it harder to use different values across environments such as development, staging, and production.

+

What is the potential impact?

+

Environment coupling

+

A hardcoded IP address is the same in every environment the application runs in. This makes it difficult to point development, staging, and +production builds at different infrastructure without modifying the source code.

+

Increased deployment friction

+

Any change to the target host—such as migrating a service, scaling out, or rotating infrastructure—requires a code change and a full redeployment +cycle. This prevents operational teams from making infrastructure adjustments independently and slows down incident response.

+

Exceptions

+

No issue is reported for the following well-known, special-purpose addresses, as they do not represent configurable infrastructure endpoints:

  • Loopback addresses 127.0.0.0/8 in CIDR notation (from 127.0.0.0 to 127.255.255.255)
  • Broadcast address 255.255.255.255
    • @@ -50,8 +29,25 @@

    Exceptions

  • Addresses in the range 2001:db8::/32, reserved for documentation purposes by RFC 3849
-

See

+

How to fix it

+

Code examples

+

The following code contains a hardcoded IP address instead of reading it from configuration or environment variables.

+

Noncompliant code example

+
+ip = '192.168.12.42' # Noncompliant
+sock = socket.socket()
+sock.bind((ip, 9090))
+
+

Compliant solution

+
+ip = config.get(section, ipAddress)
+sock = socket.socket()
+sock.bind((ip, 9090))
+
+

Resources

+

Standards

    +
  • CWE - CWE-547 - Use of Hard-coded, Security-relevant Constants
  • OWASP - Top 10 2021 Category A1 - Broken Access Control
  • OWASP - Top 10 2017 Category A3 - Sensitive Data Exposure
    • diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1313.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1313.json index a0192b2b49..218cac75ba 100644 --- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1313.json +++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1313.json @@ -1,6 +1,6 @@ { - "title": "Using hardcoded IP addresses is security-sensitive", - "type": "SECURITY_HOTSPOT", + "title": "IP addresses should not be hardcoded", + "type": "CODE_SMELL", "code": { "impacts": { "SECURITY": "LOW" @@ -13,9 +13,11 @@ "constantCost": "30min" }, "tags": [ - "bad-practice" + "bad-practice", + "former-hotspot" ], "defaultSeverity": "Minor", + "quickfix": "unknown", "ruleSpecification": "RSPEC-1313", "sqKey": "S1313", "scope": "Main", diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1523.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1523.html index 9678a7b2ea..56d2eed8f5 100644 --- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1523.html +++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1523.html @@ -1,53 +1,46 @@ -

    This rule is deprecated, and will eventually be removed.

    -

    Executing code dynamically is security-sensitive. It has led in the past to the following vulnerabilities:

    - -

    Some APIs enable the execution of dynamic code by providing it as strings at runtime. These APIs might be useful in some very specific -meta-programming use-cases. However most of the time their use is frowned upon because they also increase the risk of maliciously Injected Code. Such attacks can either run on the server or in the client (example: -XSS attack) and have a huge impact on an application’s security.

    -

    This rule marks for review each occurrence of such dynamic code execution. This rule does not detect code injections. It only highlights the use of -APIs which should be used sparingly and very carefully.

    -

    Ask Yourself Whether

    -
      -
    • the executed code may come from an untrusted source and hasn’t been sanitized.
      • -
    • you really need to run code dynamically.
      • -
    -

    There is a risk if you answered yes to any of those questions.

    -

    Recommended Secure Coding Practices

    -

    Regarding the execution of unknown code, the best solution is to not run code provided by an untrusted source. If you really need to do it, run the -code in a sandboxed environment. Use jails, firewalls and whatever means your -operating system and programming language provide (example: Security Managers in java, iframes and same-origin -policy for javascript in a web browser).

    -

    Do not try to create a blacklist of dangerous code. It is impossible to cover all attacks that way.

    -

    Avoid using dynamic code APIs whenever possible. Hard-coded code is always safer.

    -

    Sensitive Code Example

    -
    -import os
-
-value = input()
-command = 'os.system("%s")' % value
-
-def evaluate(command, file, mode):
-    eval(command)  # Sensitive.
+
    Dynamic code execution APIs allow code to be provided and executed as strings at runtime.
    
+
    Why is this an issue?
    
+
    Some APIs enable the execution of code provided as strings at runtime. These APIs might be useful in specific meta-programming use-cases, but they
+also increase the risk of code injection. When user-controlled data is included
+in the code string, an attacker can inject and execute arbitrary instructions within the application.
    
+
    Python’s eval, exec, and compile functions execute strings as Python code in the current execution
+context.
    
+
    What is the potential impact?
    
+
    When user-controlled data reaches a dynamic code execution API, an attacker can craft input that alters the intended logic of the program.
    
+
    Arbitrary code execution
    
+
    An attacker who can influence the code being executed can run arbitrary commands on the host system or within the database, potentially leading to
+full system compromise, data exfiltration, or privilege escalation.
    
+
    How to fix it
    
+
    Code examples
    
+
    Noncompliant code example
    
+
    +def run(role):
+    eval(f"handle_{role}()")  # Noncompliant
+
    
+
    Compliant solution
    
+
    +from enum import Enum
 
-eval(command)  # Sensitive. Dynamic code
+class Role(Enum):
+    USER = "user"
+    ADMIN = "admin"
 
-def execute(code, file, mode):
-    exec(code)  # Sensitive.
-    exec(compile(code, file, mode))  # Sensitive.
+HANDLERS = {
+    Role.USER: handle_user,
+    Role.ADMIN: handle_admin,
+}
 
-exec(command)  # Sensitive.
+def run(role: Role):
+    HANDLERS[role]()
 
    
-
    See
    
+
    Resources
    
+
    Standards
    
 
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1523.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1523.json
index 316596e5b6..daff4ac53a 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1523.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1523.json
@@ -1,6 +1,6 @@
 {
-  "title": "Dynamically executing code is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Dynamic code execution should not use user-controlled data",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "MAINTAINABILITY": "LOW",
@@ -8,13 +8,15 @@
     },
     "attribute": "TRUSTWORTHY"
   },
-  "status": "deprecated",
+  "status": "closed",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "30min"
   },
   "tags": [
-    "deprecated"
+    "deprecated",
+    "former-hotspot"
   ],
   "defaultSeverity": "Critical",
   "ruleSpecification": "RSPEC-1523",
@@ -41,6 +43,5 @@
       "5.2.4",
       "5.5.4"
     ]
-  },
-  "quickfix": "unknown"
+  }
 }
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1764.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1764.html
index 6cbb02f5dc..fabc51a674 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1764.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S1764.html
@@ -28,6 +28,7 @@ 
    Exceptions
    
   
  • The expression 1 << 1
    •

Resources

+

Related rules

  • {rule:python:S1656} - Implements a check on =.
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2068.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2068.json index 1aa22f50d9..fb776e6085 100644 --- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2068.json +++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2068.json @@ -3,7 +3,7 @@ "type": "VULNERABILITY", "code": { "impacts": { - "SECURITY": "BLOCKER" + "SECURITY": "MEDIUM" }, "attribute": "TRUSTWORTHY" }, @@ -14,9 +14,11 @@ }, "quickfix": "infeasible", "tags": [ - "cwe" + "cwe", + "former-hotspot", + "secret" ], - "defaultSeverity": "Blocker", + "defaultSeverity": "Major", "ruleSpecification": "RSPEC-2068", "sqKey": "S2068", "scope": "Main", diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2077.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2077.html index 1d9dfcacf5..1879100770 100644 --- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2077.html +++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2077.html @@ -1,21 +1,18 @@ -

Formatted SQL queries can be difficult to maintain, debug and can increase the risk of SQL injection when concatenating untrusted values into the -query. However, this rule doesn’t detect SQL injections (unlike rule {rule:python:S3649}), the goal is only to highlight complex/formatted -queries.

-

Ask Yourself Whether

-
    -
  • Some parts of the query come from untrusted values (like user inputs).
    • -
  • The query is repeated/duplicated in other parts of the code.
    • -
  • The application must support different types of relational databases.
    • -
-

There is a risk if you answered yes to any of those questions.

-

Recommended Secure Coding Practices

- -

Sensitive Code Example

-
+
Dynamically building SQL query strings can result in broken SQL syntax and open SQL injection attacks.

+
Why is this an issue?

+
When SQL queries are constructed by concatenating or formatting user-supplied values directly into the query string, the structure of the query
+itself can be altered by a malicious input. This rule flags calls to SQL execution functions where the query string is built using string
+concatenation or format operators rather than parameterized queries or prepared statements. Unlike rule {rule:python:S3649}, this rule does not
+perform taint analysis — it flags all dynamically formatted SQL queries as a potential risk regardless of the data source.

+
What is the potential impact?

+
SQL injection

+
If any part of a dynamically formatted query string originates from untrusted input, an attacker can manipulate the query to read, modify, or
+delete data they should not have access to, bypass authentication checks, or in some configurations execute operating system commands.

+
How to fix it

+
Code examples

+
The following code builds a SQL query by concatenating a value directly into the query string.

+
Noncompliant code example

+
 from django.db import models
 from django.db import connection
 from django.db import connections
@@ -30,39 +27,59 @@ 
Sensitive Code Example

 
 def query_my_user(request, params, value):
     with connection.cursor() as cursor:
-        cursor.execute("{0}".format(value))  # Sensitive
+        cursor.execute("{0}".format(value))  # Noncompliant
 
     # https://docs.djangoproject.com/en/2.1/ref/models/expressions/#raw-sql-expressions
 
-    RawSQL("select col from %s where mycol = %s and othercol = " + value, ("test",))  # Sensitive
+    RawSQL("select col from %s where mycol = %s and othercol = " + value, ("test",))  # Noncompliant
 
     # https://docs.djangoproject.com/en/2.1/ref/models/querysets/#extra
 
     MyUser.objects.extra(
         select={
-            'mycol':  "select col from sometable here mycol = %s and othercol = " + value}, # Sensitive
+            'mycol':  "select col from sometable here mycol = %s and othercol = " + value}, # Noncompliant
            select_params=(someparam,),
         },
     )
 

-
Compliant Solution

-
-cursor = connection.cursor(prepared=True)
-sql_insert_query = """ select col from sometable here mycol = %s and othercol = %s """
+
Compliant solution

+
+from django.db import models
+from django.db import connection
+from django.db import connections
+from django.db.models.expressions import RawSQL
+
+value = input()
 
-select_tuple = (1, value)
 
-cursor.execute(sql_insert_query, select_tuple) # Compliant, the query is parameterized
-connection.commit()
+class MyUser(models.Model):
+    name = models.CharField(max_length=200)
+
+
+def query_my_user(request, params, value):
+    with connection.cursor() as cursor:
+        cursor.execute("SELECT * FROM mytable WHERE col = %s", [value])
+
+    RawSQL("select col from %s where mycol = %s and othercol = %s", ("test", value,))
+
+    MyUser.objects.extra(
+        select={
+            'mycol': "select col from sometable where mycol = %s and othercol = %s"},
+        select_params=(someparam, value),
+    )
 

-
See

+
Resources

+
Articles & blog posts

 
+
Standards

+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2077.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2077.json
index b10fecc9e4..ada59fcb35 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2077.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2077.json
@@ -1,6 +1,6 @@
 {
-  "title": "Formatting SQL queries is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "SQL queries should not be dynamically formatted",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "MAINTAINABILITY": "LOW",
@@ -9,6 +9,7 @@
     "attribute": "COMPLETE"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "20min"
@@ -16,7 +17,8 @@
   "tags": [
     "cwe",
     "bad-practice",
-    "sql"
+    "sql",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-2077",
@@ -24,8 +26,8 @@
   "scope": "Main",
   "securityStandards": {
     "CWE": [
-      20,
-      89
+      89,
+      943
     ],
     "OWASP": [
       "A1"
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2092.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2092.html
index 32641d7cc5..c77cffa43b 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2092.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2092.html
@@ -1,43 +1,29 @@
 
When a cookie is protected with the secure attribute set to true it will not be send by the browser over an unencrypted HTTP
 request and thus cannot be observed by an unauthorized person during a man-in-the-middle attack.

-
Ask Yourself Whether

-
    
-  
  • the cookie is for instance a session-cookie not designed to be sent over non-HTTPS communication.
    • 
-  
  • it’s not sure that the website contains mixed content or not
-  (ie HTTPS everywhere or not)
    • 
-

-
There is a risk if you answered yes to any of those questions.

-
Recommended Secure Coding Practices

-
    
-  
  • It is recommended to use HTTPs everywhere so setting the secure flag to true should be the default behaviour
-  when creating cookies.
    • 
-  
  • Set the secure flag to true for session-cookies.
    • 
-

-
Sensitive Code Example

-
Using Flask:

-
+
Why is this an issue?

+
When a cookie is created without the secure attribute set to true, browsers will transmit it over unencrypted HTTP
+connections as well as HTTPS. An attacker who can observe or intercept network traffic—for example on a public Wi-Fi network—can read the cookie value
+in cleartext.

+
What is the potential impact?

+
Session hijacking

+
If a session cookie is transmitted over an unencrypted HTTP connection, an attacker who can intercept the traffic can steal it. With a valid
+session cookie, the attacker can impersonate the victim and gain full access to their account without knowing their password. Even on sites that
+primarily use HTTPS, a single HTTP request containing the session cookie is enough to expose it.

+
How to fix it in Flask

+
Pass secure=True to set_cookie to prevent the cookie from being transmitted over unencrypted HTTP connections.

+
Code examples

+
Noncompliant code example

+
 from flask import Response
 
 @app.route('/')
 def index():
     response = Response()
-    response.set_cookie('key', 'value')  # Sensitive
+    response.set_cookie('key', 'value')  # Noncompliant
     return response
 

-
Using FastAPI:

-
-from fastapi import FastAPI, Response
-
-app = FastAPI()
-
-@app.get('/')
-async def index(response: Response):
-    response.set_cookie('key', 'value')  # Sensitive
-    return {"message": "Hello world!"}
-

-
Compliant Solution

-
Using Flask:

-
+
Compliant solution

+
 from flask import Response
 
 @app.route('/')
@@ -46,8 +32,22 @@ 
Compliant Solution

     response.set_cookie('key', 'value', secure=True)
     return response
 

-
Using FastAPI:

-
+
How to fix it in FastAPI

+
Pass secure=True to set_cookie to prevent the cookie from being transmitted over unencrypted HTTP connections.

+
Code examples

+
Noncompliant code example

+
+from fastapi import FastAPI, Response
+
+app = FastAPI()
+
+@app.get('/')
+async def index(response: Response):
+    response.set_cookie('key', 'value')  # Noncompliant
+    return {"message": "Hello world!"}
+

+
Compliant solution

+
 from fastapi import FastAPI, Response
 
 app = FastAPI()
@@ -57,7 +57,8 @@ 
Compliant Solution

     response.set_cookie('key', 'value', secure=True)
     return {"message": "Hello world!"}
 

-
See

+
Resources

+
Standards

 
    
   
  • OWASP - Top 10 2021 Category A4 - Insecure Design
    • 
   
  • OWASP - Top 10 2021 Category A5 - Security Misconfiguration
    • 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2092.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2092.json
index 33f99cba2c..c021c4d24d 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2092.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2092.json
@@ -1,6 +1,7 @@
 {
-  "title": "Creating cookies without the \"secure\" flag is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Cookies should have the \"secure\" flag",
+  "type": "VULNERABILITY",
+  "quickfix": "unknown",
   "code": {
     "impacts": {
       "SECURITY": "LOW"
@@ -17,7 +18,8 @@
     "privacy",
     "fastapi",
     "django",
-    "flask"
+    "flask",
+    "former-hotspot"
   ],
   "defaultSeverity": "Minor",
   "ruleSpecification": "RSPEC-2092",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2115.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2115.json
index 38369e62a2..c7eb38ce57 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2115.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2115.json
@@ -13,7 +13,8 @@
     "constantCost": "45min"
   },
   "tags": [
-    "cwe"
+    "cwe",
+    "secret"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-2115",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2187.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2187.html
new file mode 100644
index 0000000000..f8fbf80f79
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2187.html
@@ -0,0 +1,72 @@
+
    Why is this an issue?
    
+
    Test files and test classes are meant to verify behavior. When a file looks like a test module, or a class looks like a collected test class,
+readers expect it to contain executable test cases. If it only contains helpers, fixtures, or lifecycle code, it gives the false impression that the
+covered behavior is actually tested.
    
+
    In Python, this can happen in different ways depending on the test framework:
    
+
      
+  
    • In pytest, a file such as test_example.py or example_test.py can define fixtures or helper classes but no
+  collected test functions or test methods.
      • 
+  
    • In unittest, a class can inherit from unittest.TestCase but only define setup helpers and no test_
+  methods.
      • 
+
    
+
    Such files and classes are misleading because they appear to contribute test coverage while actually verifying nothing.
    
+
    Exceptions
    
+
    There are scenarios where not having local test cases is acceptable.
    
+
    Base classes used only for shared test logic
    
+
    Shared helpers or setup code can live in a base class or mixin that is meant to be inherited by real test classes. Those classes are not
+problematic by themselves as long as the actual derived test classes contain collected tests.
    
+
    Derived classes that inherit tests
    
+
    Some test classes inherit test methods from a base class. In that case, the derived class may not declare its own test_ methods
+locally, but it still participates in real tests and should not be flagged.
    
+
    How to fix it in pytest
    
+
    To fix this issue in pytest, it is important that all test files contain at least one test case.
    
+
    Test cases in pytest are identified by:
    
+
      
+  
    • Functions prefixed with test_ in files prefixed with test_ or suffixed with _test.py
      • 
+  
    • Methods prefixed with test_ in classes prefixed with Test
      • 
+
    
+
    Code examples
    
+
    Noncompliant code example
    
+
    +# test_example.py
+class TestSomeClass:
+    pass  # Noncompliant: no test methods
+
    
+
    Compliant solution
    
+
    +# test_example.py
+class TestSomeClass:
+    def test_some_method_should_return_true(self):
+        assert some_method() is True
+
    
+
    How to fix it in unittest
    
+
    To fix this issue in unittest, it is important that all test classes that inherit from unittest.TestCase contain at least
+one test method.
    
+
    Test methods in unittest must:
    
+
      
+  
    • Be prefixed with test_
      • 
+  
    • Be part of a class that inherits from unittest.TestCase
      • 
+
    
+
    Code examples
    
+
    Noncompliant code example
    
+
    +import unittest
+
+class TestSomeClass(unittest.TestCase):
+    pass  # Noncompliant: no test methods
+
    
+
    Compliant solution
    
+
    +import unittest
+
+class TestSomeClass(unittest.TestCase):
+    def test_some_method_should_return_true(self):
+        self.assertTrue(some_method())
+
    
+
    Resources
    
+
    Documentation
    
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2187.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2187.json
new file mode 100644
index 0000000000..c86146c6ec
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2187.json
@@ -0,0 +1,25 @@
+{
+  "title": "TestCases should contain tests",
+  "type": "CODE_SMELL",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "BLOCKER"
+    },
+    "attribute": "TESTED"
+  },
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "tests",
+    "pytest",
+    "unittest"
+  ],
+  "defaultSeverity": "Blocker",
+  "ruleSpecification": "RSPEC-2187",
+  "sqKey": "S2187",
+  "scope": "Tests",
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2245.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2245.html
index 9fed31f63c..b28c702258 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2245.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2245.html
@@ -1,53 +1,53 @@
-
    PRNGs are algorithms that produce sequences of numbers that only approximate true randomness. While they are suitable for applications like
-simulations or modeling, they are not appropriate for security-sensitive contexts because their outputs can be predictable if the internal state is
-known.
    
-
    In contrast, cryptographically secure pseudorandom number generators (CSPRNGs) are designed to be secure against prediction attacks. CSPRNGs use
-cryptographic algorithms to ensure that the generated sequences are not only random but also unpredictable, even if part of the sequence or the
-internal state becomes known. This unpredictability is crucial for security-related tasks such as generating encryption keys, tokens, or any other
-values that must remain confidential and resistant to guessing attacks.
    
-
    For example, the use of non-cryptographic PRNGs has led to vulnerabilities such as:
    
-
-
    When software generates predictable values in a context requiring unpredictability, it may be possible for an attacker to guess the next value that
-will be generated, and use this guess to impersonate another user or access sensitive information. Therefore, it is critical to use CSPRNGs in any
-security-sensitive application to ensure the robustness and security of the system.
    
-
    Ask Yourself Whether
    
-
      
-  
    • the code using the generated value requires it to be unpredictable. It is the case for all encryption mechanisms or when a secret value, such as
-  a password, is hashed.
      • 
-  
    • the function you use is a non-cryptographic PRNG.
      • 
-  
    • the generated value is used multiple times.
      • 
-  
    • an attacker can access the generated value.
      • 
-
    
-
    There is a risk if you answered yes to any of those questions.
    
-
    Recommended Secure Coding Practices
    
-
      
-  
    • Only use random number generators which are recommended by
-  OWASP or any other trusted organization.
      • 
-  
    • Use the generated random values only once.
      • 
-  
    • You should not expose the generated random value. If you have to store it, make sure that the database or file is secure.
      • 
-
    
-
    Sensitive Code Example
    
-
    +
    Pseudorandom number generators (PRNGs) produce sequences that only approximate true randomness and are not suitable for security-sensitive
+contexts.
    
+
    Why is this an issue?
    
+
    When software generates predictable values in a context requiring unpredictability, an attacker who knows or can guess the internal state of the
+PRNG may predict the next value that will be generated. The rule flags the use of non-cryptographic PRNGs in contexts where a cryptographically secure
+pseudorandom number generator (CSPRNG) is required, such as generating encryption keys, tokens, or other secret values.
    
+
    What is the potential impact?
    
+
    Predictable values
    
+
    If an attacker can predict the values generated by a PRNG, they may be able to guess session tokens, encryption keys, password reset links, or
+other secrets, leading to unauthorized access or impersonation.
    
+
    Broken cryptography
    
+
    Using a non-cryptographic PRNG to generate keys or initialization vectors weakens the security of the cryptographic scheme, potentially making it
+trivially breakable.
    
+
    How to fix it
    
+
    Code examples
    
+
    Use a cryptographically secure pseudorandom number generator (CSPRNG) instead of a non-cryptographic PRNG.
    
+
    Noncompliant code example
    
+
     import random
 
-random.getrandbits(1) # Sensitive
-random.randint(0,9) # Sensitive
-random.random()  # Sensitive
+random.getrandbits(1) # Noncompliant
+random.randint(0,9) # Noncompliant
+random.random()  # Noncompliant
 
-# the following functions are sadly used to generate salt by selecting characters in a string ex: "abcdefghijk"...
-random.sample(['a', 'b'], 1)  # Sensitive
-random.choice(['a', 'b'])  # Sensitive
-random.choices(['a', 'b'])  # Sensitive
+# These functions are sometimes used to generate salts by selecting characters from a string:
+random.sample(['a', 'b'], 1)  # Noncompliant
+random.choice(['a', 'b'])  # Noncompliant
+random.choices(['a', 'b'])  # Noncompliant
 
    
-
    See
    
+
    Compliant solution
    
+
    +import secrets
+import random
+
+secrets.randbits(1)
+secrets.randbelow(10)
+secrets.token_hex(16)
+
+random.SystemRandom().sample(['a', 'b'], 1)
+secrets.choice(['a', 'b'])
+random.SystemRandom().choices(['a', 'b'])
+
    
+
    Resources
    
+
    Documentation
    
 
+
    Standards
    
+
      
   
    • OWASP - Top 10 2021 Category A2 - Cryptographic Failures
      • 
   
    • OWASP - Top 10 2017 Category A3 - Sensitive Data
   Exposure
      • 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2245.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2245.json
index 5d89023b1a..65a166377f 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2245.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2245.json
@@ -1,21 +1,23 @@
 {
-  "title": "Using pseudorandom number generators (PRNGs) is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Pseudorandom number generators (PRNGs) should not be used in security contexts",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
-      "SECURITY": "HIGH"
+      "SECURITY": "MEDIUM"
     },
     "attribute": "TRUSTWORTHY"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "10min"
   },
   "tags": [
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
-  "defaultSeverity": "Critical",
+  "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-2245",
   "sqKey": "S2245",
   "scope": "Main",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2257.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2257.html
index 2ff7e1b67a..8eb93538f5 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2257.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2257.html
@@ -1,16 +1,27 @@
-
      The use of a non-standard algorithm is dangerous because a determined attacker may be able to break the algorithm and compromise whatever data has
-been protected. Standard algorithms like Argon2PasswordHasher, BCryptPasswordHasher, …​ should be used instead.
      
-
      This rule tracks creation of BasePasswordHasher subclasses for Django applications.
      
-
      Recommended Secure Coding Practices
      
-
        
-  
      • Use a standard algorithm instead of creating a custom one.
        • 
-
      
-
      Sensitive Code Example
      
-
      -class CustomPasswordHasher(BasePasswordHasher):  # Sensitive
+
      Cryptographic operations should use proven, standard algorithms rather than custom implementations.
      
+
      Why is this an issue?
      
+
      Non-standard cryptographic algorithms are those that have not been publicly vetted by the security community or that implement cryptographic
+primitives in a custom way. Creating a custom cryptographic algorithm by subclassing standard cryptographic base classes bypasses the rigorous testing
+and peer review that established algorithms undergo. Custom implementations are likely to contain subtle flaws that could be exploited to break the
+protection the algorithm is supposed to provide.
      
+
      What is the potential impact?
      
+
      Data compromise
      
+
      When an attacker discovers a flaw in a custom cryptographic algorithm, they may be able to decrypt any data protected by it. Depending on the
+application, this could expose passwords, personal data, financial records, or other sensitive information.
      
+
      How to fix it
      
+
      This rule detects custom implementations of BasePasswordHasher subclasses for Django applications.
      
+
      Code examples
      
+
      Noncompliant code example
      
+
      +class CustomPasswordHasher(BasePasswordHasher):  # Noncompliant
     # ...
 
      
-
      See
      
+
      Compliant solution
      
+
      +from django.contrib.auth.hashers import Argon2PasswordHasher
+
      
+
      Resources
      
+
      Standards
      
 
        
   
      • OWASP - Top 10 2021 Category A2 - Cryptographic Failures
        • 
   
      • OWASP - Top 10 2017 Category A3 - Sensitive Data
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2257.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2257.json
index c6b5a75149..55d05f60d2 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2257.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2257.json
@@ -1,6 +1,6 @@
 {
-  "title": "Using non-standard cryptographic algorithms is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Custom cryptographic algorithms should not be used",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "HIGH"
@@ -12,9 +12,11 @@
     "func": "Constant\/Issue",
     "constantCost": "1d"
   },
+  "quickfix": "unknown",
   "tags": [
     "cwe",
-    "bad-practice"
+    "bad-practice",
+    "former-hotspot"
   ],
   "defaultSeverity": "Critical",
   "ruleSpecification": "RSPEC-2257",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2612.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2612.html
index 790a246a96..88450291ac 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2612.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2612.html
@@ -1,52 +1,59 @@
+
        Why is this an issue?
        
 
        In Unix file system permissions, the "others" category refers to all users except the owner of the file system resource and the
 members of the group assigned to this resource.
        
 
        Granting permissions to this category can lead to unintended access to files or directories that could allow attackers to obtain sensitive
 information, disrupt services or elevate privileges.
        
-
        Ask Yourself Whether
        
-
          
-  
        • The application is designed to be run on a multi-user environment.
          • 
-  
        • Corresponding files and directories may contain confidential information.
          • 
-
        
-
        There is a risk if you answered yes to any of those questions.
        
-
        Recommended Secure Coding Practices
        
-
        The most restrictive possible permissions should be assigned to files and directories.
        
-
        Sensitive Code Example
        
-
        For os.umask:
        
+
        What is the potential impact?
        
+
        Unauthorized access to sensitive information
        
+
        When file or directory permissions grant access to all users on a system (often represented as "others" or "everyone" in permission models),
+attackers who gain access to any user account can read sensitive files containing credentials, configuration data, API keys, database passwords,
+personal information, or proprietary business data. This exposure can lead to data breaches, identity theft, compliance violations, and competitive
+disadvantage.
        
+
        Service disruption and data corruption
        
+
        Granting write permissions to broad user categories allows any user on the system to modify or delete critical files and directories. Attackers or
+compromised low-privileged accounts can corrupt application data, modify configuration files to alter system behavior or disrupt services, or delete
+important resources, leading to service outages, system instability, data loss, and denial of service.
        
+
        Privilege escalation
        
+
        When executable files or scripts have overly permissive permissions, especially when combined with special permission bits that allow programs to
+execute with the permissions of the file owner or group rather than the executing user, attackers can replace legitimate executables with malicious
+code. When these modified files are executed by privileged users or processes, the attacker’s code runs with elevated privileges, potentially enabling
+them to escalate from a low-privileged account to root or administrator access, install backdoors, or pivot to other systems in the network.
        
+
        How to fix it
        
+
        When using os.umask, set a restrictive umask value that prevents permissions for "others". The umask value 0o777 ensures
+that no permissions are granted to any category by default. This is the most secure approach as it requires explicit permission grants rather than
+implicit ones.
        
+
        Code examples
        
+
        Noncompliant code example
        
 
        -os.umask(0)  # Sensitive
-
        
-
        For os.chmod, os.lchmod, and os.fchmod:
        
-
        -os.chmod("/tmp/fs", stat.S_IRWXO)   # Sensitive
-os.lchmod("/tmp/fs", stat.S_IRWXO)  # Sensitive
-os.fchmod(fd, stat.S_IRWXO)         # Sensitive
+os.umask(0)  # Noncompliant
 
        
-
        Compliant Solution
        
-
        For os.umask:
        
+
        Compliant solution
        
 
         os.umask(0o777)
 
        
-
        For os.chmod, os.lchmod, and os.fchmod:
        
-
        -os.chmod("/tmp/fs", stat.S_IRWXU)
-os.lchmod("/tmp/fs", stat.S_IRWXU)
-os.fchmod(fd, stat.S_IRWXU)
-
        
-
        See
        
+
        Resources
        
+
        Documentation
        
+
+
        Standards
        
 
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2612.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2612.json
index f4878e4fa5..bec6543230 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2612.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2612.json
@@ -1,6 +1,6 @@
 {
-  "title": "Setting loose POSIX file permissions is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "File permissions should not be set to world-accessible values",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
@@ -13,7 +13,8 @@
     "constantCost": "5min"
   },
   "tags": [
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-2612",
@@ -43,5 +44,6 @@
     "STIG ASD_V5R3": [
       "V-222430"
     ]
-  }
+  },
+  "quickfix": "unknown"
 }
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2712.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2712.html
index 11bc3106b6..8aa712a3a2 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2712.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2712.html
@@ -1,14 +1,37 @@
+
        This rule raises an issue when a return statement with a value is used inside a generator function (a function that uses
+yield).
        
 
        Why is this an issue?
        
-
        Functions that use yield are known as "generators". Before Python 3.3, generators cannot return values. Similarly,
-functions that use return cannot use yield. Doing so will cause a SyntaxError.
        
-
        Either upgrade your version of Python to a version >= 3.3, or don’t use both return and yield in a function.
        
-
        Noncompliant code example
        
-
        -def adder(n):
-     num = 0
-     while num < n:
-         yield num
-         num += 1
-     return num  #Noncompliant
+
        When a generator function uses return with a value, the value is not sent to the caller like a normal function return. Instead, it is
+silently attached to the StopIteration exception’s value attribute. Most callers iterate generators with a for
+loop, which swallows StopIteration automatically and discards the returned value entirely. This makes the return value
+effectively invisible and can lead to subtle bugs where developers expect the value to be accessible but it never reaches the calling code.
        
+
        A bare return (without a value) in a generator is fine — it simply ends the generator’s execution early, similar to how
+return works in a regular function.
        
+
        How to fix it
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +def counter(n):
+    num = 0
+    while num < n:
+        yield num
+        num += 1
+    return num  # Noncompliant: return with a value in a generator
 
        
+
        Compliant solution
        
+
        +def counter(n):
+    num = 0
+    while num < n:
+        yield num
+        num += 1
+    return  # Compliant: bare return for early exit is fine
+
        
+
        Resources
        
+
        Documentation
        
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2712.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2712.json
index eb3319db26..1d1a26c5c2 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2712.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2712.json
@@ -1,5 +1,5 @@
 {
-  "title": "\"return\" and \"yield\" should not be used in the same function",
+  "title": "\"return\" with a value should not be used in a generator function",
   "type": "BUG",
   "code": {
     "impacts": {
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3330.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3330.html
index 01688167fd..58d4d371e2 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3330.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3330.html
@@ -1,45 +1,30 @@
-
        When a cookie is configured with the HttpOnly attribute set to true, the browser guaranties that no client-side script will
-be able to read it. In most cases, when a cookie is created, the default value of HttpOnly is false and it’s up to the developer
-to decide whether or not the content of the cookie can be read by the client-side script. As a majority of Cross-Site Scripting (XSS) attacks target
-the theft of session-cookies, the HttpOnly attribute can help to reduce their impact as it won’t be possible to exploit the XSS
-vulnerability to steal session-cookies.
        
-
        Ask Yourself Whether
        
-
          
-  
        • the cookie is sensitive, used to authenticate the user, for instance a session-cookie
          • 
-  
        • the HttpOnly attribute offer an additional protection (not the case for an XSRF-TOKEN cookie / CSRF token for
-  example)
          • 
-
        
-
        There is a risk if you answered yes to any of those questions.
        
-
        Recommended Secure Coding Practices
        
-
          
-  
        • By default the HttpOnly flag should be set to true for most of the cookies and it’s mandatory for session /
-  sensitive-security cookies.
          • 
-
        
-
        Sensitive Code Example
        
-
        Using Flask:
        
-
        +
        Setting the HttpOnly attribute on cookies prevents client-side scripts from reading their values, limiting the damage that cross-site
+scripting (XSS) attacks can cause.
        
+
        Why is this an issue?
        
+
        When a cookie is created without the HttpOnly attribute, or with it explicitly set to false, client-side scripts running
+in the browser can read the cookie’s value. By default, cookies are created with HttpOnly set to false, meaning they are
+accessible to browser scripts unless the developer explicitly enables this protection. Setting HttpOnly to true instructs
+the browser to block script access to the cookie, limiting the damage from XSS attacks that attempt to steal session credentials.
        
+
        What is the potential impact?
        
+
        Session hijacking and account takeover
        
+
        The most common target of cookie theft is the session cookie used to authenticate a user. If an attacker can exploit an XSS vulnerability on a page
+where a session cookie is accessible to scripts, they can steal it and use it to impersonate the authenticated user without needing their credentials.
+This can lead to unauthorized access to sensitive account data, account takeover, and potential privilege escalation within the application.
        
+
        How to fix it in Flask
        
+
        Code examples
        
+
        The following code creates a cookie without enabling the HttpOnly attribute.
        
+
        Noncompliant code example
        
+
         from flask import Response
 
 @app.route('/')
 def index():
     response = Response()
-    response.set_cookie('key', 'value')  # Sensitive
+    response.set_cookie('key', 'value')  # Noncompliant
     return response
 
        
-
        Using FastAPI:
        
-
        -from fastapi import FastAPI, Response
-
-app = FastAPI()
-
-@app.get('/')
-async def index(response: Response):
-    response.set_cookie('key', 'value')  # Sensitive
-    return {"message": "Hello world!"}
-
        
-
        Compliant Solution
        
-
        Using Flask:
        
-
        +
        Compliant solution
        
+
         from flask import Response
 
 @app.route('/')
@@ -48,8 +33,22 @@ 
        Compliant Solution
        
     response.set_cookie('key', 'value', httponly=True)
     return response
 
        
-
        Using FastAPI:
        
-
        +
        How to fix it in FastAPI
        
+
        Code examples
        
+
        The following code creates a cookie without enabling the HttpOnly attribute.
        
+
        Noncompliant code example
        
+
        +from fastapi import FastAPI, Response
+
+app = FastAPI()
+
+@app.get('/')
+async def index(response: Response):
+    response.set_cookie('key', 'value')  # Noncompliant
+    return {"message": "Hello world!"}
+
        
+
        Compliant solution
        
+
         from fastapi import FastAPI, Response
 
 app = FastAPI()
@@ -59,14 +58,17 @@ 
        Compliant Solution
        
     response.set_cookie('key', 'value', httponly=True)
     return {"message": "Hello world!"}
 
        
-
        See
        
+
        Resources
        
+
        Documentation
        
 
+
        Standards
        
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3330.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3330.json
index 0576e96381..f2594c192d 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3330.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3330.json
@@ -1,6 +1,6 @@
 {
-  "title": "Creating cookies without the \"HttpOnly\" flag is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Cookies should have the \"HttpOnly\" flag",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "LOW"
@@ -12,12 +12,14 @@
     "func": "Constant\/Issue",
     "constantCost": "10min"
   },
+  "quickfix": "unknown",
   "tags": [
     "cwe",
     "privacy",
     "flask",
     "fastapi",
-    "django"
+    "django",
+    "former-hotspot"
   ],
   "defaultSeverity": "Minor",
   "ruleSpecification": "RSPEC-3330",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3415.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3415.html
new file mode 100644
index 0000000000..4d91d49e7a
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3415.html
@@ -0,0 +1,106 @@
+
        This rule raises an issue when a test file mixes both assertion argument-order conventions: some assertions put the actual value first, and others
+put the expected value first.
        
+
        Why is this an issue?
        
+
        Assertions check that the code under test produces the expected results. When you write an equality assertion, one operand is the value from the
+code under test (the actual value) and the other is what you expect (the expected value).
        
+
        Python testing frameworks commonly recommend putting the expected value second (the actual value first):
        
+
          
+  
        • In unittest, methods like assertEqual() and assertIs() take the actual value first and the expected value
+  second, for example self.assertEqual(s.split(), ['hello', 'world']).
          • 
+  
        • In pytest, equality assertions place the actual value on the left and the expected value on the right, for example assert
+  result == 42. Helpers such as pytest.approx() wrap the expected value on the right-hand side.
          • 
+  
        • In assertpy, fluent assertions place the actual value in assert_that(…​) and the expected value in the assertion
+  method, such as .is_equal_to(…​).
          • 
+
        
+
        This rule does not enforce that framework default. It does not raise when a file consistently uses a different order, including when every
+assertion puts the expected value first. It raises only when the same file mixes both orders: readers must then re-interpret each assertion, and
+failure messages become harder to scan.
        
+
        The rule reports at most one issue per file. The primary location is the first assertion whose order can be determined. Two data flows group every
+order-determinable assertion in the file: one for actual-first usages and one for expected-first usages.
        
+
        A true positive is a file that mixes both orders among assertions whose operands can be classified. Using an order other than the framework’s
+documented default is fine as long as the file is consistent. Mid-migration inconsistency is still a true positive; finish unifying or temporarily
+suppress the issue until the file is consistent. A false positive would mean the analyzer misclassified an operand (for example, treating a
+non-constant expression as expected, or the reverse), so the reported "mix" is not real.
        
+
        What is the potential impact?
        
+
        Mixing conventions does not change whether tests pass or fail. It does make failures harder to read and slows down reviews, because each assertion
+must be interpreted individually instead of following one file-wide pattern.
        
+
        For example, if one test writes self.assertEqual(runner.exit_code, 0) and another in the same file writes self.assertEqual(0,
+runner.exit_code), both may be correct in isolation, but the file no longer has a single readable convention.
        
+
        How to fix it
        
+
        Unify the file so every order-determinable assertion follows the same convention. Prefer picking one convention for the whole file and swapping the
+operands of the assertions that use the other convention.
        
+
        Quick fixes can rewrite every mismatched assertion in the file in either direction: put all expected values second (actual first), or put all
+actual values second (expected first).
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +import unittest
+
+class TestRunner(unittest.TestCase):
+    def test_exit_code(self):
+        runner = Runner()
+        self.assertEqual(0, runner.exit_code)  # Noncompliant; file mixes both orders
+        self.assertEqual(runner.name, "ok")
+
        
+
        Compliant solution
        
+
        +import unittest
+
+class TestRunner(unittest.TestCase):
+    def test_exit_code(self):
+        runner = Runner()
+        self.assertEqual(runner.exit_code, 0)
+        self.assertEqual(runner.name, "ok")
+
        
+
        Noncompliant code example
        
+
        +import pytest
+
+EXPECTED_PI = 3.14
+
+def test_calculation():
+    result = perform_calculation()
+    assert 3.14 == result  # Noncompliant; file mixes both orders
+    assert result == pytest.approx(EXPECTED_PI)
+
        
+
        Compliant solution
        
+
        +import pytest
+
+EXPECTED_PI = 3.14
+
+def test_calculation():
+    result = perform_calculation()
+    assert result == 3.14
+    assert result == pytest.approx(EXPECTED_PI)
+
        
+
        Noncompliant code example
        
+
        +from assertpy import assert_that
+
+EXPECTED_EXIT_CODE = 0
+
+def test_exit_code():
+    runner = Runner()
+    assert_that(EXPECTED_EXIT_CODE).is_equal_to(runner.exit_code)  # Noncompliant; file mixes both orders
+    assert_that(runner.name).is_equal_to("ok")
+
        
+
        Compliant solution
        
+
        +from assertpy import assert_that
+
+EXPECTED_EXIT_CODE = 0
+
+def test_exit_code():
+    runner = Runner()
+    assert_that(runner.exit_code).is_equal_to(EXPECTED_EXIT_CODE)
+    assert_that(runner.name).is_equal_to("ok")
+
        
+
        Resources
        
+
        Documentation
        
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3415.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3415.json
new file mode 100644
index 0000000000..708852e87c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3415.json
@@ -0,0 +1,24 @@
+{
+  "title": "Assertion argument order should be consistent within a file",
+  "type": "CODE_SMELL",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  },
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "2min"
+  },
+  "tags": [
+    "tests",
+    "suspicious"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-3415",
+  "sqKey": "S3415",
+  "scope": "Tests",
+  "quickfix": "partial"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3752.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3752.html
index 828b11e50d..c9afa18f9e 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3752.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3752.html
@@ -1,78 +1,46 @@
-
        An HTTP method is safe when used to perform a read-only operation, such as retrieving information. In contrast, an unsafe HTTP method is used to
-change the state of an application, for instance to update a user’s profile on a web application.
        
-
        Common safe HTTP methods are GET, HEAD, or OPTIONS.
        
-
        Common unsafe HTTP methods are POST, PUT and DELETE.
        
-
        Allowing both safe and unsafe HTTP methods to perform a specific operation on a web application could impact its security, for example CSRF
-protections are most of the time only protecting operations performed by unsafe HTTP methods.
        
-
        Ask Yourself Whether
        
-
          
-  
        • HTTP methods are not defined at all for a route/controller of the application.
          • 
-  
        • Safe HTTP methods are defined and used for a route/controller that can change the state of an application.
          • 
-
        
-
        There is a risk if you answered yes to any of those questions.
        
-
        Recommended Secure Coding Practices
        
-
        For all the routes/controllers of an application, the authorized HTTP methods should be explicitly defined and safe HTTP methods should only be
-used to perform read-only operations.
        
-
        Sensitive Code Example
        
-
        For Django:
        
-
        +
        HTTP routes that do not explicitly restrict which HTTP methods are allowed accept both safe (read-only) and unsafe (state-changing) methods, which
+can expose the application to CSRF attacks.
        
+
        Why is this an issue?
        
+
        HTTP methods are divided into safe methods (GET, HEAD, OPTIONS), which are intended for read-only operations, and unsafe methods (POST, PUT,
+DELETE), which are intended for state-changing operations. When a route does not restrict which methods it accepts, an attacker can trigger
+state-changing behavior through a safe method such as GET. CSRF protections typically only apply to unsafe methods, so a route that accepts both can
+be exploited via a crafted link or image tag without requiring the attacker to bypass CSRF defenses.
        
+
        What is the potential impact?
        
+
        Cross-Site Request Forgery
        
+
        An attacker can craft a malicious link or page that causes a victim’s browser to issue a state-changing HTTP request to the vulnerable route.
+Because the request originates from the victim’s authenticated session, the server processes it as legitimate, allowing the attacker to perform
+actions such as deleting records, changing account settings, or initiating transactions on behalf of the victim.
        
+
        How to fix it in Django
        
+
        Code examples
        
+
        The following noncompliant example shows a route that applies no method restriction, allowing any HTTP verb to trigger state-changing behavior.
+Each compliant example restricts the route to only the methods appropriate for its purpose.
        
+
        Noncompliant code example
        
+
         # No method restriction
-def view(request):  # Sensitive
-    return HttpResponse("...")
-
        
-
        -@require_http_methods(["GET", "POST"])  # Sensitive
-def view(request):
+def view(request):  # Noncompliant
     return HttpResponse("...")
 
        
-
        For Flask:
        
-
        -@methods.route('/sensitive', methods=['GET', 'POST'])  # Sensitive
-def view():
-    return Response("...", 200)
-
        
-
        Compliant Solution
        
-
        For Django:
        
-
        +
        Compliant solution
        
+
         @require_http_methods(["POST"])
 def view(request):
     return HttpResponse("...")
 
        
-
        -@require_POST
-def view(request):
-    return HttpResponse("...")
-
        
-
        -@require_GET
-def view(request):
-    return HttpResponse("...")
-
        
-
        -@require_safe
-def view(request):
-    return HttpResponse("...")
-
        
-
        For Flask:
        
-
        -@methods.route('/compliant1')
-def view():
-    return Response("...", 200)
-
        
-
        -@methods.route('/compliant2', methods=['GET'])
-def view():
-    return Response("...", 200)
-
        
-
        See
        
+
        Resources
        
+
        Documentation
        
+
          
+  
        • Django - Allowed HTTP Methods
          • 
+
        
+
        Articles & blog posts
        
+
          
+  
        • OWASP - Cross-Site Request Forgery
          • 
+
        
+
        Standards
        
 
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3752.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3752.json
index 81ad61671c..0a4cc1cc77 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3752.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S3752.json
@@ -1,6 +1,6 @@
 {
-  "title": "Allowing both safe and unsafe HTTP methods is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "HTTP routes should restrict allowed HTTP methods",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "LOW"
@@ -8,14 +8,15 @@
     "attribute": "COMPLETE"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "5min"
   },
   "tags": [
     "cwe",
-    "flask",
-    "django"
+    "django",
+    "former-hotspot"
   ],
   "defaultSeverity": "Minor",
   "ruleSpecification": "RSPEC-3752",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4426.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4426.html
index 2e09927ab1..db93fdf93a 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4426.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4426.html
@@ -291,6 +291,8 @@ 
        Standards
        
   Use of Cryptographic Algorithms and Key Lengths
        • 
   
      • CWE - CWE-326 - Inadequate Encryption Strength
        • 
   
      • CWE - CWE-327 - Use of a Broken or Risky Cryptographic Algorithm
        • 
-  
      • CERT, MSC61-J. - Do not use insecure or weak cryptographic algorithms
        • 
+  
      • CERT,
+  MSC61-J. - Do not use insecure or weak cryptographic algorithms
        • 
 
      
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4502.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4502.html
index cc1f6636b7..2ec957ee34 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4502.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4502.html
@@ -1,34 +1,23 @@
-
      A cross-site request forgery (CSRF) attack occurs when a trusted user of a web application can be forced, by an attacker, to perform sensitive
-actions that he didn’t intend, such as updating his profile or sending a message, more generally anything that can change the state of the
-application.
      
-
      The attacker can trick the user/victim to click on a link, corresponding to the privileged action, or to visit a malicious web site that embeds a
-hidden web request and as web browsers automatically include cookies, the actions can be authenticated and sensitive.
      
-
      Ask Yourself Whether
      
-
        
-  
      • The web application uses cookies to authenticate users.
        • 
-  
      • There exist sensitive operations in the web application that can be performed when the user is authenticated.
        • 
-  
      • The state / resources of the web application can be modified by doing HTTP POST or HTTP DELETE requests for example.
        • 
-
      
-
      There is a risk if you answered yes to any of those questions.
      
-
      Recommended Secure Coding Practices
      
-
        
-  
      • Protection against CSRF attacks is strongly recommended:
-    
          
-      
        • to be activated by default for all unsafe HTTP
-      methods.
          • 
-      
        • implemented, for example, with an unguessable CSRF token
          • 
-    
        • 
-  
      • Of course all sensitive operations should not be performed with safe HTTP methods like GET which are designed to be
-  used only for information retrieval.
        • 
-
      
-
      Sensitive Code Example
      
-
      For a Django application, the code is sensitive when,
      
-
        
-  
      • django.middleware.csrf.CsrfViewMiddleware is not used in the Django settings:
        • 
-
      
-
      +
      Cross-site request forgery (CSRF) forces an authenticated user to perform unintended state-changing actions in a web application. This rule detects
+when CSRF protection is explicitly disabled or missing from an application.
      
+
      Why is this an issue?
      
+
      When CSRF protection is disabled or bypassed, an attacker can trick a logged-in user into submitting requests the application treats as
+authenticated. The rule flags configurations that disable framework CSRF middleware, exempt specific routes or views, or leave unsafe HTTP methods
+unprotected.
      
+
      What is the potential impact?
      
+
      Unauthorized state changes
      
+
      An attacker can change passwords, transfer funds, modify data, or perform other privileged operations using the victim’s session.
      
+
      Account compromise
      
+
      Successful CSRF attacks can lead to full account takeover when combined with sensitive actions such as email or credential changes.
      
+
      How to fix it in Django
      
+
      Enable django.middleware.csrf.CsrfViewMiddleware in settings and do not exempt views from CSRF protection unless strictly
+necessary.
      
+
      Code examples
      
+
      Disabling or bypassing CSRF protection allows an authenticated user’s browser to execute state-changing requests the user did not intend.
      
+
      Noncompliant code example
      
+
      django.middleware.csrf.CsrfViewMiddleware is not used in the Django
+settings:
      
+
       MIDDLEWARE = [
     'django.middleware.security.SecurityMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
@@ -36,115 +25,111 @@ 
      Sensitive Code Example
      
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'django.middleware.clickjacking.XFrameOptionsMiddleware',
-] # Sensitive: django.middleware.csrf.CsrfViewMiddleware is missing
+] # Noncompliant: django.middleware.csrf.CsrfViewMiddleware is missing
 
      
-
        
-  
      • the CSRF protection is disabled on a view:
        • 
-
      
-
      -@csrf_exempt # Sensitive
+
      The CSRF protection is disabled on a view:
      
+
      +@csrf_exempt # Noncompliant
 def example(request):
     return HttpResponse("default")
 
      
-
      For a Flask application, the code is sensitive when,
      
-
        
-  
      • the WTF_CSRF_ENABLED setting is set to false:
        • 
-
      
-
      +
      Compliant solution
      
+
      Protect all views with django.middleware.csrf.CsrfViewMiddleware:
      
+
      +MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
      
+
      Do not disable the CSRF protection on specific views:
      
+
      +def example(request):
+    return HttpResponse("default")
+
      
+
      How to fix it in Flask
      
+
      Use the CSRFProtect module from Flask-WTF and keep WTF_CSRF_ENABLED enabled.
      
+
      Code examples
      
+
      Disabling or bypassing CSRF protection allows an authenticated user’s browser to execute state-changing requests the user did not intend.
      
+
      Noncompliant code example
      
+
      The WTF_CSRF_ENABLED setting is set to false:
      
+
       app = Flask(__name__)
-app.config['WTF_CSRF_ENABLED'] = False # Sensitive
+app.config['WTF_CSRF_ENABLED'] = False # Noncompliant
 
      
-
        
-  
      • the application doesn’t use the CSRFProtect module:
        • 
-
      
-
      -app = Flask(__name__) # Sensitive: CSRFProtect is missing
+
      The application doesn’t use the CSRFProtect module:
      
+
      +app = Flask(__name__) # Noncompliant: CSRFProtect is missing
 
 @app.route('/')
 def hello_world():
     return 'Hello, World!'
 
      
-
        
-  
      • the CSRF protection is disabled on a view:
        • 
-
      
-
      -app = Flask(__name__)
-csrf = CSRFProtect()
-csrf.init_app(app)
-
+
      The CSRF protection is disabled on a view:
      
+
       @app.route('/example/', methods=['POST'])
-@csrf.exempt # Sensitive
+@csrf.exempt # Noncompliant
 def example():
     return 'example '
 
      
-
        
-  
      • the CSRF protection is disabled on a form:
        • 
-
      
-
      +
      The CSRF protection is disabled on a form:
      
+
       class unprotectedForm(FlaskForm):
     class Meta:
-        csrf = False # Sensitive
+        csrf = False # Noncompliant
 
     name = TextField('name')
     submit = SubmitField('submit')
 
      
-
      Compliant Solution
      
-
      For a Django application,
      
-
        
-  
      • it is recommended to protect all the views with django.middleware.csrf.CsrfViewMiddleware:
        • 
-
      
-
      -MIDDLEWARE = [
-    'django.middleware.security.SecurityMiddleware',
-    'django.contrib.sessions.middleware.SessionMiddleware',
-    'django.middleware.common.CommonMiddleware',
-    'django.middleware.csrf.CsrfViewMiddleware', # Compliant
-    'django.contrib.auth.middleware.AuthenticationMiddleware',
-    'django.contrib.messages.middleware.MessageMiddleware',
-    'django.middleware.clickjacking.XFrameOptionsMiddleware',
-]
-
      
-
        
-  
      • and to not disable the CSRF protection on specific views:
        • 
-
      
-
      -def example(request): # Compliant
-    return HttpResponse("default")
+
      Compliant solution
      
+
      Use the CSRFProtect module (and do not disable it with WTF_CSRF_ENABLED set to false):
      
+
      +app = Flask(__name__)
+csrf = CSRFProtect()
+csrf.init_app(app)
 
      
-
      For a Flask application,
      
-
        
-  
      • the CSRFProtect module should be used (and not disabled further with WTF_CSRF_ENABLED set to false):
        • 
-
      
-
      +
       app = Flask(__name__)
 csrf = CSRFProtect()
-csrf.init_app(app) # Compliant
+csrf.init_app(app)
 
      
-
        
-  
      • and it is recommended to not disable the CSRF protection on specific views or forms:
        • 
-
      
-
      -@app.route('/example/', methods=['POST']) # Compliant
+
      Do not disable the CSRF protection on specific views or forms:
      
+
      +@app.route('/example/', methods=['POST'])
 def example():
     return 'example '
-
+
      
+
       class unprotectedForm(FlaskForm):
     class Meta:
-        csrf = True # Compliant
+        csrf = True
 
     name = TextField('name')
     submit = SubmitField('submit')
 
      
-
      See
      
+
      Resources
      
+
      Documentation
      
+
        
+  
      • Django - Cross Site Request Forgery protection
        • 
+  
      • Flask-WTF - CSRF protection
        • 
+  
      • OWASP - Cross-Site Request Forgery
        • 
+
      
+
      Articles & blog posts
      
+
+
      Standards
      
 
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4502.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4502.json
index 193b217b5e..3d55a4e8d0 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4502.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4502.json
@@ -1,6 +1,6 @@
 {
-  "title": "Disabling CSRF protections is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "CSRF protections should not be disabled",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "HIGH"
@@ -8,6 +8,7 @@
     "attribute": "CONVENTIONAL"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "5min"
@@ -15,7 +16,8 @@
   "tags": [
     "cwe",
     "django",
-    "flask"
+    "flask",
+    "former-hotspot"
   ],
   "defaultSeverity": "Critical",
   "ruleSpecification": "RSPEC-4502",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4507.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4507.html
index 8b635f1e3f..2f621bf65b 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4507.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4507.html
@@ -1,37 +1,60 @@
-
      Development tools and frameworks usually have options to make debugging easier for developers. Although these features are useful during
-development, they should never be enabled for applications deployed in production. Debug instructions or error messages can leak detailed information
-about the system, like the application’s path or file names.
      
-
      Ask Yourself Whether
      
-
        
-  
      • The code or configuration enabling the application debug features is deployed on production servers or distributed to end users.
        • 
-  
      • The application runs by default with debug features activated.
        • 
-
      
-
      There is a risk if you answered yes to any of those questions.
      
-
      Recommended Secure Coding Practices
      
-
      Do not enable debugging features on production servers or applications distributed to end users.
      
-
      Sensitive Code Example
      
-
      Django application startup:
      
+
      Development tools and frameworks usually have options to make debugging easier for developers, but these features should never be enabled for
+applications deployed in production.
      
+
      Why is this an issue?
      
+
      Debug instructions or error messages can leak detailed information about the system, such as the application’s path, file names, or stack traces.
+The rule flags configurations and API calls that enable debug features, including stack trace printing, verbose logging, debug mode flags, and remote
+debugging endpoints.
      
+
      What is the potential impact?
      
+
      Information disclosure
      
+
      Attackers can exploit debug output to learn internal application details, file paths, stack traces, and configuration data that can be leveraged to
+craft further attacks.
      
+
      Increased attack surface
      
+
      Debug features may expose remote debugging endpoints, profiling APIs, or detailed error pages that significantly increase the attack surface of the
+application.
      
+
      How to fix it in Django
      
+
      Code examples
      
+
      Debug features should be disabled or guarded by environment checks before deploying to production.
      
+
      Noncompliant code example
      
+
      django.conf.settings.configure is called with debug settings enabled in the Django settings:
      
 
       from django.conf import settings
 
-settings.configure(DEBUG=True)  # Sensitive when set to True
-settings.configure(DEBUG_PROPAGATE_EXCEPTIONS=True)  # Sensitive when set to True
+settings.configure(DEBUG=True)  # Noncompliant
+settings.configure(DEBUG_PROPAGATE_EXCEPTIONS=True)  # Noncompliant
 
 def custom_config(config):
-    settings.configure(default_settings=config, DEBUG=True)  # Sensitive
+    settings.configure(default_settings=config, DEBUG=True)  # Noncompliant
 
      
 
      Inside settings.py or global_settings.py, which are the default configuration files for a Django application:
      
 
      -DEBUG = True  # Sensitive
-DEBUG_PROPAGATE_EXCEPTIONS = True  # Sensitive
+DEBUG = True  # Noncompliant
+DEBUG_PROPAGATE_EXCEPTIONS = True  # Noncompliant
+
      
+
      Compliant solution
      
+
      +from django.conf import settings
+
+settings.configure(DEBUG=False)
+settings.configure(DEBUG_PROPAGATE_EXCEPTIONS=False)
+
+def custom_config(config):
+    settings.configure(default_settings=config, DEBUG=False)
+
      
+
      +DEBUG = False
+DEBUG_PROPAGATE_EXCEPTIONS = False
 
      
-
      Flask application startup:
      
+
      How to fix it in Flask
      
+
      Code examples
      
+
      Debug features should be disabled or guarded by environment checks before deploying to production.
      
+
      Noncompliant code example
      
 
       from flask import Flask
 
 app = Flask()
-app.debug = True  # Sensitive
-app.run(debug=True)  # Sensitive
+app.debug = True  # Noncompliant
+app.run(debug=True)  # Noncompliant
 
      
 
      The following code defines a GraphQL endpoint with GraphiQL enabled. While this might be a useful configuration during development, it should never
 be enabled for applications deployed in production:
      
@@ -46,24 +69,11 @@ 
      Sensitive Code Example
      
     view_func=GraphQLView.as_view(
         'graphql',
         schema=schema,
-        graphiql=True # Sensitive
+        graphiql=True # Noncompliant
     )
 )
 
      
-
      Compliant Solution
      
-
      -from django.conf import settings
-
-settings.configure(DEBUG=False)
-settings.configure(DEBUG_PROPAGATE_EXCEPTIONS=False)
-
-def custom_config(config):
-    settings.configure(default_settings=config, DEBUG=False)
-
      
-
      -DEBUG = False
-DEBUG_PROPAGATE_EXCEPTIONS = False
-
      
+
      Compliant solution
      
 
       from flask import Flask
 
@@ -85,7 +95,8 @@ 
      Compliant Solution
      
     )
 )
 
      
-
      See
      
+
      Resources
      
+
      Standards
      
 
        
   
      • OWASP - Top 10 2021 Category A5 - Security Misconfiguration
        • 
   
      • OWASP - Top 10 2017 Category A3 - Sensitive Data
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4507.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4507.json
index 343ed14d23..c61a4d4f81 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4507.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4507.json
@@ -1,6 +1,6 @@
 {
-  "title": "Delivering code in production with debug features activated is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Debugging features should not be enabled in production",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "LOW"
@@ -8,6 +8,7 @@
     "attribute": "CONVENTIONAL"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "1min"
@@ -16,7 +17,8 @@
     "cwe",
     "error-handling",
     "debug",
-    "user-experience"
+    "user-experience",
+    "former-hotspot"
   ],
   "defaultSeverity": "Minor",
   "ruleSpecification": "RSPEC-4507",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4721.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4721.html
index e7021b3a5c..8f4b8f6ddf 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4721.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4721.html
@@ -1,81 +1,29 @@
-
        This rule is deprecated, and will eventually be removed.
        
 
        Arbitrary OS command injection vulnerabilities are more likely when a shell is spawned rather than a new process, indeed shell meta-chars can be
 used (when parameters are user-controlled for instance) to inject OS commands.
        
-
        Ask Yourself Whether
        
-
          
-  
        • OS command name or parameters are user-controlled.
          • 
-
        
-
        There is a risk if you answered yes to this question.
        
-
        Recommended Secure Coding Practices
        
-
        Use functions that don’t spawn a shell.
        
-
        Sensitive Code Example
        
-
        Python 3
        
-
        -subprocess.run(cmd, shell=True)  # Sensitive
-subprocess.Popen(cmd, shell=True)  # Sensitive
-subprocess.call(cmd, shell=True)  # Sensitive
-subprocess.check_call(cmd, shell=True)  # Sensitive
-subprocess.check_output(cmd, shell=True)  # Sensitive
-os.system(cmd)  # Sensitive: a shell is always spawn
-
        
-
        Python 2
        
-
        -cmd = "when a string is passed through these function, a shell is spawn"
-(_, child_stdout, _) = os.popen2(cmd)  # Sensitive
-(_, child_stdout, _) = os.popen3(cmd)  # Sensitive
-(_, child_stdout) = os.popen4(cmd)  # Sensitive
-
-
-(child_stdout, _) = popen2.popen2(cmd)  # Sensitive
-(child_stdout, _, _) = popen2.popen3(cmd)  # Sensitive
-(child_stdout, _) = popen2.popen4(cmd)  # Sensitive
+
        Why is this an issue?
        
+
        When a shell interpreter is used to execute OS commands, shell meta-characters in user-controlled input can be exploited to inject additional
+commands. Functions that spawn a shell process—such as os.system() in Python, exec() in JavaScript, or
+Runtime.exec() in Java—create an attack surface for OS command injection that would not exist if a new process were spawned directly
+without a shell. This is especially dangerous when the command name or parameters are derived from user input.
        
+
        What is the potential impact?
        
+
        An attacker who can control the OS command name or its parameters can inject arbitrary OS commands that execute with the privileges of the
+application. This can lead to complete system compromise, unauthorized data access, or the installation of malware on the host.
        
+
        How to fix it in Python Standard Library
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +subprocess.run(cmd, shell=True)  # Noncompliant
+subprocess.Popen(cmd, shell=True)  # Noncompliant
+os.system(cmd)  # Noncompliant: a shell is always spawned
 
        
-
        Compliant Solution
        
-
        Python 3
        
-
        -# by default shell=False, a shell is not spawn
-subprocess.run(cmd)  # Compliant
-subprocess.Popen(cmd)  # Compliant
-subprocess.call(cmd)  # Compliant
-subprocess.check_call(cmd)  # Compliant
-subprocess.check_output(cmd)  # Compliant
-
-# always in a subprocess:
-os.spawnl(mode, path, *cmd)  # Compliant
-os.spawnle(mode, path, *cmd, env)  # Compliant
-os.spawnlp(mode, file, *cmd)  # Compliant
-os.spawnlpe(mode, file, *cmd, env)  # Compliant
-os.spawnv(mode, path, cmd)  # Compliant
-os.spawnve(mode, path, cmd, env)  # Compliant
-os.spawnvp(mode, file, cmd)  # Compliant
-os.spawnvpe(mode, file, cmd, env)  # Compliant
-
-(child_stdout) = os.popen(cmd, mode, 1)  # Compliant
-(_, output) = subprocess.getstatusoutput(cmd)  # Compliant
-out = subprocess.getoutput(cmd)  # Compliant
-os.startfile(path)  # Compliant
-os.execl(path, *cmd)  # Compliant
-os.execle(path, *cmd, env)  # Compliant
-os.execlp(file, *cmd)  # Compliant
-os.execlpe(file, *cmd, env)  # Compliant
-os.execv(path, cmd)  # Compliant
-os.execve(path, cmd, env)  # Compliant
-os.execvp(file, cmd)  # Compliant
-os.execvpe(file, cmd, env)  # Compliant
-
        
-
        Python 2
        
-
        -cmdsargs = ("use", "a", "sequence", "to", "directly", "start", "a", "subprocess")
-
-(_, child_stdout) = os.popen2(cmdsargs)  # Compliant
-(_, child_stdout, _) = os.popen3(cmdsargs)  # Compliant
-(_, child_stdout) = os.popen4(cmdsargs)  # Compliant
-
-(child_stdout, _) = popen2.popen2(cmdsargs)  # Compliant
-(child_stdout, _, _) = popen2.popen3(cmdsargs)  # Compliant
-(child_stdout, _) = popen2.popen4(cmdsargs)  # Compliant
+
        Compliant solution
        
+
        +# shell=False by default; no shell is spawned
+subprocess.run(cmd)
+subprocess.Popen(cmd)
 
        
-
        See
        
+
        Resources
        
+
        Standards
        
 
          
   
        • OWASP - Top 10 2021 Category A3 - Injection
          • 
   
        • OWASP - Top 10 2017 Category A1 - Injection
          • 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4721.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4721.json
index 9d984fa93a..679d1bcd19 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4721.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4721.json
@@ -1,19 +1,21 @@
 {
-  "title": "Using shell interpreter when executing OS commands is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "OS commands should not be executed using a shell interpreter",
+  "type": "VULNERABILITY",
+  "quickfix": "unknown",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
     },
     "attribute": "TRUSTWORTHY"
   },
-  "status": "deprecated",
+  "status": "closed",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "30min"
   },
   "tags": [
-    "deprecated"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-4721",
@@ -33,6 +35,5 @@
       "12.3.5",
       "5.3.8"
     ]
-  },
-  "quickfix": "unknown"
+  }
 }
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4784.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4784.html
deleted file mode 100644
index aca34dc3f6..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4784.html
+++ /dev/null
@@ -1,92 +0,0 @@
-
          This rule is deprecated; use {rule:python:S5852}, {rule:pythonsecurity:S2631} instead.
          
-
          Using regular expressions is security-sensitive. It has led in the past to the following vulnerabilities:
          
-
-
          Evaluating regular expressions against input strings is potentially an extremely CPU-intensive task. Specially crafted regular expressions such as
-(a+)+s will take several seconds to evaluate the input string aaaaaaaaaaaaaaaaaaaaaaaaaaaaabs. The problem is that with
-every additional a character added to the input, the time required to evaluate the regex doubles. However, the equivalent regular
-expression, a+s (without grouping) is efficiently evaluated in milliseconds and scales linearly with the input size.
          
-
          Evaluating such regular expressions opens the door to Regular expression Denial of Service (ReDoS) attacks.
-In the context of a web application, attackers can force the web server to spend all of its resources evaluating regular expressions thereby making
-the service inaccessible to genuine users.
          
-
          This rule flags any execution of a hardcoded regular expression which has at least 3 characters and at least two instances of any of the following
-characters: *+{.
          
-
          Example: (a+)*
          
-
          Ask Yourself Whether
          
-
            
-  
          • the executed regular expression is sensitive and a user can provide a string which will be analyzed by this regular expression.
            • 
-  
          • your regular expression engine performance decrease with specially crafted inputs and regular expressions.
            • 
-
          
-
          There is a risk if you answered yes to any of those questions.
          
-
          Recommended Secure Coding Practices
          
-
          Check whether your regular expression engine (the algorithm executing your regular expression) has any known vulnerabilities. Search for
-vulnerability reports mentioning the one engine you’re are using.
          
-
          Use if possible a library which is not vulnerable to Redos Attacks such as Google Re2.
          
-
          Remember also that a ReDos attack is possible if a user-provided regular expression is executed. This rule won’t detect this kind of injection.
          
-
          Sensitive Code Example
          
-
          Django
          
-
          -from django.core.validators import RegexValidator
-from django.urls import re_path
-
-RegexValidator('(a*)*b')  # Sensitive
-
-def define_http_endpoint(view):
-    re_path(r'^(a*)*b/$', view)  # Sensitive
-
          
-
          re module
          
-
          -import re
-from re import compile, match, search, fullmatch, split, findall, finditer, sub, subn
-
-
-input = 'input string'
-replacement = 'replacement'
-
-re.compile('(a*)*b')  # Sensitive
-re.match('(a*)*b', input)  # Sensitive
-re.search('(a*)*b', input)  # Sensitive
-re.fullmatch('(a*)*b', input)  # Sensitive
-re.split('(a*)*b', input)  # Sensitive
-re.findall('(a*)*b', input)  # Sensitive
-re.finditer('(a*)*b',input)  # Sensitive
-re.sub('(a*)*b', replacement, input)  # Sensitive
-re.subn('(a*)*b', replacement, input)  # Sensitive
-
          
-
          regex module
          
-
          -import regex
-from regex import compile, match, search, fullmatch, split, findall, finditer, sub, subn, subf, subfn, splititer
-
-input = 'input string'
-replacement = 'replacement'
-
-regex.subf('(a*)*b', replacement, input)  # Sensitive
-regex.subfn('(a*)*b', replacement, input)  # Sensitive
-regex.splititer('(a*)*b', input)  # Sensitive
-
-regex.compile('(a*)*b')  # Sensitive
-regex.match('(a*)*b', input)  # Sensitive
-regex.search('(a*)*b', input)  # Sensitive
-regex.fullmatch('(a*)*b', input)  # Sensitive
-regex.split('(a*)*b', input)  # Sensitive
-regex.findall('(a*)*b', input)  # Sensitive
-regex.finditer('(a*)*b',input)  # Sensitive
-regex.sub('(a*)*b', replacement, input)  # Sensitive
-regex.subn('(a*)*b', replacement, input)  # Sensitive
-
          
-
          Exceptions
          
-
          Some corner-case regular expressions will not raise an issue even though they might be vulnerable. For example: (a|aa)+,
-(a|a?)+.
          
-
          It is a good idea to test your regular expression if it has the same pattern on both side of a "|".
          
-
          See
          
-
-
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4784.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4784.json
deleted file mode 100644
index a54d16c4ee..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4784.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "title": "Using regular expressions is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
-  "status": "deprecated",
-  "tags": [
-    "deprecated"
-  ],
-  "defaultSeverity": "Critical",
-  "ruleSpecification": "RSPEC-4784",
-  "sqKey": "S4784",
-  "scope": "Main"
-}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4787.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4787.html
deleted file mode 100644
index faca90420b..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4787.html
+++ /dev/null
@@ -1,101 +0,0 @@
-
          This rule is deprecated; use {rule:python:S4426}, {rule:python:S5542}, {rule:python:S5547} instead.
          
-
          Encrypting data is security-sensitive. It has led in the past to the following vulnerabilities:
          
-
-
          Proper encryption requires both the encryption algorithm and the key to be strong. Obviously the private key needs to remain secret and be renewed
-regularly. However these are not the only means to defeat or weaken an encryption.
          
-
          This rule flags function calls that initiate encryption/decryption.
          
-
          Ask Yourself Whether
          
-
            
-  
          • the private key might not be random, strong enough or the same key is reused for a long long time.
            • 
-  
          • the private key might be compromised. It can happen when it is stored in an unsafe place or when it was transferred in an unsafe manner.
            • 
-  
          • the key exchange is made without properly authenticating the receiver.
            • 
-  
          • the encryption algorithm is not strong enough for the level of protection required. Note that encryption algorithms strength decreases as time
-  passes.
            • 
-  
          • the chosen encryption library is deemed unsafe.
            • 
-  
          • a nonce is used, and the same value is reused multiple times, or the nonce is not random.
            • 
-  
          • the RSA algorithm is used, and it does not incorporate an Optimal Asymmetric Encryption Padding (OAEP), which might weaken the encryption.
            • 
-  
          • the CBC (Cypher Block Chaining) algorithm is used for encryption, and it’s IV (Initialization Vector) is not generated using a secure random
-  algorithm, or it is reused.
            • 
-  
          • the Advanced Encryption Standard (AES) encryption algorithm is used with an unsecure mode. See the recommended practices for more
-  information.
            • 
-
          
-
          You are at risk if you answered yes to any of those questions.
          
-
          Recommended Secure Coding Practices
          
-
            
-  
          • Generate encryption keys using secure random algorithms.
            • 
-  
          • When generating cryptographic keys (or key pairs), it is important to use a key length that provides enough entropy against brute-force attacks.
-  For the Blowfish algorithm the key should be at least 128 bits long, while for the RSA algorithm it should be at least 2048 bits long.
            • 
-  
          • Regenerate the keys regularly.
            • 
-  
          • Always store the keys in a safe location and transfer them only over safe channels.
            • 
-  
          • If there is an exchange of cryptographic keys, check first the identity of the receiver.
            • 
-  
          • Only use strong encryption algorithms. Check regularly that the algorithm is still deemed secure. It is also imperative that they are
-  implemented correctly. Use only encryption libraries which are deemed secure. Do not define your own encryption algorithms as they will most
-  probably have flaws.
            • 
-  
          • When a nonce is used, generate it randomly every time.
            • 
-  
          • When using the RSA algorithm, incorporate an Optimal Asymmetric Encryption Padding (OAEP).
            • 
-  
          • When CBC is used for encryption, the IV must be random and unpredictable. Otherwise it exposes the encrypted value to crypto-analysis attacks
-  like "Chosen-Plaintext Attacks". Thus a secure random algorithm should be used. An IV value should be associated to one and only one encryption
-  cycle, because the IV’s purpose is to ensure that the same plaintext encrypted twice will yield two different ciphertexts.
            • 
-  
          • The Advanced Encryption Standard (AES) encryption algorithm can be used with various modes. Galois/Counter Mode (GCM) with no padding should be
-  preferred to the following combinations which are not secured:
-    
              
-      
            • Electronic Codebook (ECB) mode: Under a given key, any given plaintext block always gets encrypted to the same ciphertext block. Thus, it
-      does not hide data patterns well. In some senses, it doesn’t provide serious message confidentiality, and it is not recommended for use in
-      cryptographic protocols at all.
              • 
-      
            • Cipher Block Chaining (CBC) with PKCS#5 padding (or PKCS#7) is susceptible to padding oracle attacks.
              • 
-    
            • 
-
          
-
          Sensitive Code Example
          
-
          cryptography module
          
-
          -from cryptography.fernet import Fernet
-from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305, AESGCM, AESCCM
-from cryptography.hazmat.primitives.asymmetric import rsa
-from cryptography.hazmat.primitives.ciphers import Cipher
-
-
-def encrypt(key):
-    Fernet(key)  # Sensitive
-    ChaCha20Poly1305(key)  # Sensitive
-    AESGCM(key)  # Sensitive
-    AESCCM(key)  # Sensitive
-
-
-private_key = rsa.generate_private_key()  # Sensitive
-
-
-def encrypt2(algorithm, mode, backend):
-    Cipher(algorithm, mode, backend)  # Sensitive
-
          
-
          pynacl library
          
-
          -from nacl.public import Box
-from nacl.secret import SecretBox
-
-
-def public_encrypt(secret_key, public_key):
-    Box(secret_key, public_key)  # Sensitive
-
-
-def secret_encrypt(key):
-    SecretBox(key)  # Sensitive
-
          
-
          See
          
-
-
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4787.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4787.json
deleted file mode 100644
index 0e5f556c83..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4787.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "title": "Encrypting data is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
-  "code": {
-    "impacts": {
-      "SECURITY": "HIGH"
-    },
-    "attribute": "TRUSTWORTHY"
-  },
-  "status": "deprecated",
-  "tags": [
-    "deprecated"
-  ],
-  "defaultSeverity": "Critical",
-  "ruleSpecification": "RSPEC-4787",
-  "sqKey": "S4787",
-  "scope": "Main"
-}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4790.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4790.html
index 9a6b2b2579..9b6656894c 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4790.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4790.html
@@ -1,43 +1,42 @@
-
          Cryptographic hash algorithms such as MD2, MD4, MD5, MD6, HAVAL-128,
-DSA (which uses SHA-1), RIPEMD, RIPEMD-128, RIPEMD-160and SHA-1 are no
-longer considered secure, because it is possible to have collisions (little computational effort is enough to find two or more different
-inputs that produce the same hash).
          
-
          Message authentication code (MAC) algorithms such as HMAC-MD5 or HMAC-SHA1 use weak hash functions as building blocks.
-Although they are not all proven to be weak, they are considered legacy algorithms and should be avoided.
          
-
          Ask Yourself Whether
          
-
          The hashed value is used in a security context like:
          
-
            
-  
          • User-password storage.
            • 
-  
          • Security token generation (used to confirm e-mail when registering on a website, reset password, etc …​).
            • 
-  
          • To compute some message integrity.
            • 
-
          
-
          There is a risk if you answered yes to any of those questions.
          
-
          Recommended Secure Coding Practices
          
-
          Safer alternatives, such as SHA-256, SHA-512, SHA-3 are recommended, and for password hashing, it’s even
-better to use algorithms that do not compute too "quickly", like bcrypt, scrypt, argon2 or pbkdf2
-because it slows down brute force attacks.
          
-
          Sensitive Code Example
          
-
          -import hashlib
-m = hashlib.md5() // Sensitive
-
          
-
          +
          Using a weak hashing algorithm to protect sensitive data can compromise the security guarantees the hash is meant to provide.
          
+
          Why is this an issue?
          
+
          Cryptographic hash algorithms such as MD2, MD4, MD5, MD6, HAVAL-128, DSA (which uses SHA-1), RIPEMD, RIPEMD-128, RIPEMD-160, and SHA-1 are no
+longer considered secure, because it is computationally feasible to find two different inputs that produce the same hash output — a collision. Message
+authentication code (MAC) algorithms such as HMAC-MD5 or HMAC-SHA1 use these weak hash functions as building blocks and are likewise considered legacy
+algorithms. When a weak hashing algorithm is used to protect sensitive data — such as storing passwords, generating security tokens, or verifying data
+integrity — its weakness can be exploited to defeat that protection.
          
+
          What is the potential impact?
          
+
          Breach of confidentiality
          
+
          When weak hashing is used for password storage or security tokens, an attacker who obtains the hashed values can recover the original data more
+easily through brute force or precomputed (rainbow table) attacks.
          
+
          Data integrity compromise
          
+
          When weak hashing is used to verify the integrity of data or downloaded files, an attacker can craft a different input that produces the same hash,
+allowing them to substitute malicious content without detection.
          
+
          How to fix it
          
+
          To hash passwords or other sensitive data, use a slow, memory-hard algorithm specifically designed for that purpose. In order of preference:
+Argon2, scrypt, bcrypt, or PBKDF2. These algorithms make brute-force and rainbow-table attacks
+computationally expensive.
          
+
          For non-sensitive use cases such as data integrity or fingerprinting, use a modern cryptographic hash function such as SHA-256,
+SHA-512, or SHA-3.
          
+
          Code examples
          
+
          The following noncompliant example uses a weak hashing algorithm that is vulnerable to collision and preimage attacks.
          
+
          Noncompliant code example
          
+
           import hashlib
-m = hashlib.sha1() // Sensitive
+m = hashlib.md5() # Noncompliant
 
          
-
          -import md5 // Sensitive and deprecated since Python 2.5; use the hashlib module instead.
-m = md5.new()
-
-import sha // Sensitive and deprecated since Python 2.5; use the hashlib module instead.
-m = sha.new()
-
          
-
          Compliant Solution
          
-
          +
          Compliant solution
          
+
           import hashlib
-m = hashlib.sha512() // Compliant
+m = hashlib.sha512()
 
          
-
          See
          
+
          Resources
          
+
          Documentation
          
+
+
          Standards
          
 
            
   
          • OWASP - Top 10 2021 Category A2 - Cryptographic Failures
            • 
   
          • OWASP - Top 10 2017 Category A3 - Sensitive Data
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4790.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4790.json
index abae695d0e..10b0f1e664 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4790.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4790.json
@@ -1,6 +1,6 @@
 {
-  "title": "Using weak hashing algorithms is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Weak hashing algorithms should not be used",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "HIGH"
@@ -8,8 +8,14 @@
     "attribute": "TRUSTWORTHY"
   },
   "status": "ready",
+  "quickfix": "unknown",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "30min"
+  },
   "tags": [
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Critical",
   "ruleSpecification": "RSPEC-4790",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4792.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4792.html
deleted file mode 100644
index 15eeaa2e44..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4792.html
+++ /dev/null
@@ -1,101 +0,0 @@
-
            This rule is deprecated, and will eventually be removed.
            
-
            Configuring loggers is security-sensitive. It has led in the past to the following vulnerabilities:
            
-            
-
            Logs are useful before, during and after a security incident.
            
-
              
-  
            • Attackers will most of the time start their nefarious work by probing the system for vulnerabilities. Monitoring this activity and stopping it
-  is the first step to prevent an attack from ever happening.
              • 
-  
            • In case of a successful attack, logs should contain enough information to understand what damage an attacker may have inflicted.
              • 
-
            
-
            Logs are also a target for attackers because they might contain sensitive information. Configuring loggers has an impact on the type of information
-logged and how they are logged.
            
-
            This rule flags for review code that initiates loggers configuration. The goal is to guide security code reviews.
            
-
            Ask Yourself Whether
            
-
              
-  
            • unauthorized users might have access to the logs, either because they are stored in an insecure location or because the application gives access
-  to them.
              • 
-  
            • the logs contain sensitive information on a production server. This can happen when the logger is in debug mode.
              • 
-  
            • the log can grow without limit. This can happen when additional information is written into logs every time a user performs an action and the
-  user can perform the action as many times as he/she wants.
              • 
-  
            • the logs do not contain enough information to understand the damage an attacker might have inflicted. The loggers mode (info, warn, error) might
-  filter out important information. They might not print contextual information like the precise time of events or the server hostname.
              • 
-  
            • the logs are only stored locally instead of being backuped or replicated.
              • 
-
            
-
            There is a risk if you answered yes to any of those questions.
            
-
            Recommended Secure Coding Practices
            
-
              
-  
            • Check that your production deployment doesn’t have its loggers in "debug" mode as it might write sensitive information in logs.
              • 
-  
            • Production logs should be stored in a secure location which is only accessible to system administrators.
              • 
-  
            • Configure the loggers to display all warnings, info and error messages. Write relevant information such as the precise time of events and the
-  hostname.
              • 
-  
            • Choose log format which is easy to parse and process automatically. It is important to process logs rapidly in case of an attack so that the
-  impact is known and limited.
              • 
-  
            • Check that the permissions of the log files are correct. If you index the logs in some other service, make sure that the transfer and the
-  service are secure too.
              • 
-  
            • Add limits to the size of the logs and make sure that no user can fill the disk with logs. This can happen even when the user does not control
-  the logged information. An attacker could just repeat a logged action many times.
              • 
-
            
-
            Remember that configuring loggers properly doesn’t make them bullet-proof. Here is a list of recommendations explaining on how to use your
-logs:
            
-
              
-  
            • Don’t log any sensitive information. This obviously includes passwords and credit card numbers but also any personal information such as user
-  names, locations, etc…​ Usually any information which is protected by law is good candidate for removal.
              • 
-  
            • Sanitize all user inputs before writing them in the logs. This includes checking its size, content, encoding, syntax, etc…​ As for any user
-  input, validate using whitelists whenever possible. Enabling users to write what they want in your logs can have many impacts. It could for example
-  use all your storage space or compromise your log indexing service.
              • 
-  
            • Log enough information to monitor suspicious activities and evaluate the impact an attacker might have on your systems. Register events such as
-  failed logins, successful logins, server side input validation failures, access denials and any important transaction.
              • 
-  
            • Monitor the logs for any suspicious activity.
              • 
-
            
-
            Sensitive Code Example
            
-
            -import logging
-from logging import Logger, Handler, Filter
-from logging.config import fileConfig, dictConfig
-
-logging.basicConfig()  # Sensitive
-
-logging.disable()  # Sensitive
-
-
-def update_logging(logger_class):
-    logging.setLoggerClass(logger_class)  # Sensitive
-
-
-def set_last_resort(last_resort):
-    logging.lastResort = last_resort  # Sensitive
-
-
-class CustomLogger(Logger):  # Sensitive
-    pass
-
-
-class CustomHandler(Handler):  # Sensitive
-    pass
-
-
-class CustomFilter(Filter):  # Sensitive
-    pass
-
-
-def update_config(path, config):
-    fileConfig(path)  # Sensitive
-    dictConfig(config)  # Sensitive
-
            
-
            See
            
-
-
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4792.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4792.json
deleted file mode 100644
index 5a14b6c4e0..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4792.json
+++ /dev/null
@@ -1,43 +0,0 @@
-{
-  "title": "Configuring loggers is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
-  "code": {
-    "impacts": {
-      "SECURITY": "HIGH"
-    },
-    "attribute": "CONVENTIONAL"
-  },
-  "status": "deprecated",
-  "tags": [
-    "deprecated"
-  ],
-  "defaultSeverity": "Critical",
-  "ruleSpecification": "RSPEC-4792",
-  "sqKey": "S4792",
-  "scope": "Main",
-  "securityStandards": {
-    "CWE": [
-      117,
-      532
-    ],
-    "OWASP": [
-      "A3",
-      "A10"
-    ],
-    "OWASP Top 10 2021": [
-      "A9"
-    ],
-    "PCI DSS 3.2": [
-      "10.1",
-      "10.2",
-      "10.3"
-    ],
-    "PCI DSS 4.0": [
-      "10.2"
-    ],
-    "ASVS 4.0": [
-      "7.1.1",
-      "7.1.2"
-    ]
-  }
-}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4823.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4823.html
deleted file mode 100644
index a1a0acc3f5..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4823.html
+++ /dev/null
@@ -1,30 +0,0 @@
-
            This rule is deprecated, and will eventually be removed.
            
-
            Using command line arguments is security-sensitive. It has led in the past to the following vulnerabilities:
            
-
-
            Command line arguments can be dangerous just like any other user input. They should never be used without being first validated and sanitized.
            
-
            Remember also that any user can retrieve the list of processes running on a system, which makes the arguments provided to them visible. Thus
-passing sensitive information via command line arguments should be considered as insecure.
            
-
            This rule raises an issue on every reference to sys.argv, call to optparse.OptionParser() or a call to
-argparse.ArgumentParser(). The goal is to guide security code reviews.
            
-
            Ask Yourself Whether
            
-
              
-  
            • any of the command line arguments are used without being sanitized first.
              • 
-  
            • your application accepts sensitive information via command line arguments.
              • 
-
            
-
            If you answered yes to any of these questions you are at risk.
            
-
            Recommended Secure Coding Practices
            
-
            Sanitize all command line arguments before using them.
            
-
            Any user or application can list running processes and see the command line arguments they were started with. There are safer ways of providing
-sensitive information to an application than exposing them in the command line. It is common to write them on the process' standard input, or give the
-path to a file containing the information.
            
-
            See
            
-
-
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4823.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4823.json
deleted file mode 100644
index c420aa3b8b..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4823.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "title": "Using command line arguments is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
-  "status": "deprecated",
-  "tags": [
-    "deprecated"
-  ],
-  "defaultSeverity": "Critical",
-  "ruleSpecification": "RSPEC-4823",
-  "sqKey": "S4823",
-  "scope": "Main"
-}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4828.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4828.html
index 6e8764ac1c..b80da7ad0f 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4828.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4828.html
@@ -1,37 +1,31 @@
-
            Signaling processes or process groups can seriously affect the stability of this application or other applications on the same system.
            
-
            Accidentally setting an incorrect PID or signal or allowing untrusted sources to assign arbitrary values to these
-parameters may result in a denial of service.
            
-
            Also, the system treats the signal differently if the destination PID is less than or equal to 0. This different behavior may affect
-multiple processes with the same (E)UID simultaneously if the call is left uncontrolled.
            
-
            Ask Yourself Whether
            
-
              
-  
            • The parameters pid and sig are untrusted (they come from an external source).
              • 
-  
            • This function is triggered by non-administrators.
              • 
-  
            • Signal handlers on the target processes stop important functions.
              • 
-
            
-
            There is a risk if you answered yes to any of those questions.
            
-
            Recommended Secure Coding Practices
            
-
              
-  
            • For stateful applications with user management, ensure that only administrators trigger this code.
              • 
-  
            • Verify that the pid and sig parameters are correct before using them.
              • 
-  
            • Ensure that the process sending the signals runs with as few OS privileges as possible.
              • 
-  
            • Isolate the process on the system based on its (E)UID.
              • 
-  
            • Ensure that the signal does not interrupt any essential functions when intercepted by a target’s signal handlers.
              • 
-
            
-
            Sensitive Code Example
            
-
            +
            This rule is deprecated, and will eventually be removed.
            
+
            Sending OS signals without validating the target process ID or signal type can seriously affect the stability of the application or other processes
+on the system.
            
+
            Why is this an issue?
            
+
            OS signals control process execution: they can pause, terminate, or interrupt a process. When the destination PID or signal type are
+derived from untrusted input without validation, an attacker can target arbitrary processes, including processes they do not own. Additionally, using
+a non-positive PID sends the signal to an entire process group simultaneously, multiplying the impact of an uncontrolled call.
            
+
            What is the potential impact?
            
+
            Denial of service
            
+
            An attacker who controls the PID or signal value can terminate or interrupt arbitrary processes, including critical system services.
+This can crash the application, destabilize the host, or deny service to all other users of the system.
            
+
            How to fix it
            
+
            Code examples
            
+
            The following code passes a process identifier received directly from user input to the signal function.
            
+
            Noncompliant code example
            
+
             import os
 
 @app.route("/kill-pid/<pid>")
 def send_signal(pid):
-    os.kill(pid, 9)  # Sensitive
+    os.kill(pid, 9)  # Noncompliant
 
 @app.route("/kill-pgid/<pgid>")
 def send_signal(pgid):
-    os.killpg(pgid, 9)  # Sensitive
+    os.killpg(pgid, 9)  # Noncompliant
 
            
-
            Compliant Solution
            
-
            +
            Compliant solution
            
+
             import os
 
 @app.route("/kill-pid/<pid>")
@@ -48,10 +42,14 @@ 
            Compliant Solution
            
     if is_valid_pgid(pgid):
         os.kill(pgid, 9)
 
            
-
            See
            
+
            Resources
            
+
            Documentation
            
 
+
            Standards
            
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4828.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4828.json
index 26f9422d67..a7c9d73cc6 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4828.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4828.json
@@ -1,15 +1,21 @@
 {
-  "title": "Signaling processes is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "OS process signal parameters should be validated",
+  "type": "CODE_SMELL",
   "code": {
     "impacts": {
       "SECURITY": "HIGH"
     },
     "attribute": "CONVENTIONAL"
   },
-  "status": "ready",
+  "status": "deprecated",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "30min"
+  },
+  "quickfix": "unknown",
   "tags": [
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Critical",
   "ruleSpecification": "RSPEC-4828",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4829.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4829.html
deleted file mode 100644
index 9b5934c89f..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4829.html
+++ /dev/null
@@ -1,67 +0,0 @@
-
            This rule is deprecated, and will eventually be removed.
            
-
            Reading Standard Input is security-sensitive. It has led in the past to the following vulnerabilities:
            
-
-
            It is common for attackers to craft inputs enabling them to exploit software vulnerabilities. Thus any data read from the standard input (stdin)
-can be dangerous and should be validated.
            
-
            This rule flags code that reads from the standard input.
            
-
            Ask Yourself Whether
            
-
              
-  
            • data read from the standard input is not sanitized before being used.
              • 
-
            
-
            You are at risk if you answered yes to this question.
            
-
            Recommended Secure Coding Practices
            
-
            Sanitize all data read from the standard input before using it.
            
-
            Sensitive Code Example
            
-
            Python 2 and Python 3
            
-
            -import sys
-from sys import stdin, __stdin__
-
-# Any reference to sys.stdin or sys.__stdin__ without a method call is Sensitive
-sys.stdin  # Sensitive
-
-for line in sys.stdin:  # Sensitive
-    print(line)
-
-it = iter(sys.stdin)  # Sensitive
-line = next(it)
-
-# Calling the following methods on stdin or __stdin__ is sensitive
-sys.stdin.read()  # Sensitive
-sys.stdin.readline()  # Sensitive
-sys.stdin.readlines()  # Sensitive
-
-# Calling other methods on stdin or __stdin__ does not require a review, thus it is not Sensitive
-sys.stdin.seekable()  # Ok
-# ...
-
            
-
            Python 2 only
            
-
            -raw_input('What is your password?')  # Sensitive
-
            
-
            Python 3 only
            
-
            -input('What is your password?')  # Sensitive
-
            
-
            Function fileinput.input and class fileinput.FileInput read the standard input when the list of files is empty.
            
-
            -for line in fileinput.input():  # Sensitive
-    print(line)
-
-for line in fileinput.FileInput():  # Sensitive
-    print(line)
-
-for line in fileinput.input(['setup.py']):  # Ok
-    print(line)
-
-for line in fileinput.FileInput(['setup.py']):  # Ok
-    print(line)
-
            
-
            See
            
-
-
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4829.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4829.json
deleted file mode 100644
index 46820f467e..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S4829.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "title": "Reading the Standard Input is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
-  "status": "deprecated",
-  "tags": [
-    "deprecated"
-  ],
-  "defaultSeverity": "Critical",
-  "ruleSpecification": "RSPEC-4829",
-  "sqKey": "S4829",
-  "scope": "Main"
-}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5042.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5042.html
index 320f97e593..b007ab645b 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5042.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5042.html
@@ -1,48 +1,34 @@
+
            This rule is deprecated, and will eventually be removed.
            
 
            Successful Zip Bomb attacks occur when an application expands untrusted archive files without controlling the size of the expanded data, which can
 lead to denial of service. A Zip bomb is usually a malicious archive file of a few kilobytes of compressed data but turned into gigabytes of
 uncompressed data. To achieve this extreme compression ratio, attackers will
 compress irrelevant data (eg: a long string of repeated bytes).
            
-
            Ask Yourself Whether
            
-
            Archives to expand are untrusted and:
            
-
              
-  
            • There is no validation of the number of entries in the archive.
              • 
-  
            • There is no validation of the total size of the uncompressed data.
              • 
-  
            • There is no validation of the ratio between the compressed and uncompressed archive entry.
              • 
-
            
-
            There is a risk if you answered yes to any of those questions.
            
-
            Recommended Secure Coding Practices
            
-
              
-  
            • Define and control the ratio between compressed and uncompressed data, in general the data compression ratio for most of the legit archives is 1
-  to 3.
              • 
-  
            • Define and control the threshold for maximum total size of the uncompressed data.
              • 
-  
            • Count the number of file entries extracted from the archive and abort the extraction if their number is greater than a predefined threshold, in
-  particular it’s not recommended to recursively expand archives (an entry of an archive could be also an archive).
              • 
-
            
-
            Sensitive Code Example
            
-
            For tarfile module:
            
-
            +
            Why is this an issue?
            
+
            Expanding archive files without controlling the size of the extracted data can lead to denial of service. A Zip bomb is a malicious archive of a
+few kilobytes of compressed data that expands into gigabytes of uncompressed data by compressing highly repetitive content. Applications that fail to
+validate the number of entries, total uncompressed size, or compression ratio of an archive are vulnerable to this attack.
            
+
            What is the potential impact?
            
+
            Denial of service
            
+
            An attacker who can supply a malicious archive can exhaust the server’s disk space, memory, or CPU by triggering unbounded decompression. This can
+make the application completely unavailable to legitimate users and may require manual intervention to recover the affected system.
            
+
            How to fix it in tarfile
            
+
            Validate the number of entries and total uncompressed size when extracting archive files. Note that the tarfile module does not expose
+compressed entry sizes, so compression ratio checking is not applicable here.
            
+
            Code examples
            
+
            Noncompliant code example
            
+
             import tarfile
 
 tfile = tarfile.open("TarBomb.tar")
-tfile.extractall('./tmp/')  # Sensitive
+tfile.extractall('./tmp/')  # Noncompliant
 tfile.close()
 
            
-
            For zipfile module:
            
-
            -import zipfile
-
-zfile = zipfile.ZipFile('ZipBomb.zip', 'r')
-zfile.extractall('./tmp/') # Sensitive
-zfile.close()
-
            
-
            Compliant Solution
            
-
            For tarfile module:
            
-
            +
            Compliant solution
            
+
             import tarfile
 
 THRESHOLD_ENTRIES = 10000
 THRESHOLD_SIZE = 1000000000
-THRESHOLD_RATIO = 10
 
 totalSizeArchive = 0;
 totalEntryArchive = 0;
@@ -50,6 +36,8 @@ 
            Compliant Solution
            
 tfile = tarfile.open("TarBomb.tar")
 for entry in tfile:
   tarinfo = tfile.extractfile(entry)
+  if tarinfo is None:
+    continue  # skip directories, symlinks, etc.
 
   totalEntryArchive += 1
   sizeEntry = 0
@@ -58,9 +46,8 @@ 
            Compliant Solution
            
     sizeEntry += 1024
     totalSizeArchive += 1024
 
-    ratio = sizeEntry / entry.size
-    if ratio > THRESHOLD_RATIO:
-      # ratio between compressed and uncompressed data is highly suspicious, looks like a Zip Bomb Attack
+    if totalSizeArchive > THRESHOLD_SIZE:
+      # the uncompressed data size is too much for the application resource capacity
       break
 
     chunk = tarinfo.read(1024)
@@ -73,14 +60,24 @@ 
            Compliant Solution
            
     # too much entries in this archive, can lead to inodes exhaustion of the system
     break
 
-  if totalSizeArchive > THRESHOLD_SIZE:
-    # the uncompressed data size is too much for the application resource capacity
-    break
-
 tfile.close()
 
            
-
            For zipfile module:
            
-
            +
            How to fix it in zipfile
            
+
            Validate the number of entries, total uncompressed size, and compression ratio when extracting archive files. Note that zfile.read()
+fully decompresses each entry into memory before the size check runs, since the zipfile module has no streaming per-entry extraction API.
+This pattern protects against entry-count attacks but cannot prevent a single malicious entry from causing an out-of-memory condition before the check
+fires.
            
+
            Code examples
            
+
            Noncompliant code example
            
+
            +import zipfile
+
+zfile = zipfile.ZipFile('ZipBomb.zip', 'r')
+zfile.extractall('./tmp/') # Noncompliant
+zfile.close()
+
            
+
            Compliant solution
            
+
             import zipfile
 
 THRESHOLD_ENTRIES = 10000
@@ -113,7 +110,12 @@ 
            Compliant Solution
            
 
 zfile.close()
 
            
-
            See
            
+
            Resources
            
+
            Articles & blog posts
            
+
+
            Standards
            
 
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5042.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5042.json
index 073e73bd02..66bfa02dd0 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5042.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5042.json
@@ -1,21 +1,23 @@
 {
-  "title": "Expanding archive files without controlling resource consumption is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Expanding archive files should not be done without controlling resource consumption",
+  "type": "CODE_SMELL",
+  "quickfix": "unknown",
   "code": {
     "impacts": {
-      "SECURITY": "HIGH"
+      "RELIABILITY": "MEDIUM"
     },
     "attribute": "COMPLETE"
   },
-  "status": "ready",
+  "status": "deprecated",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "10min"
   },
   "tags": [
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
-  "defaultSeverity": "Critical",
+  "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-5042",
   "sqKey": "S5042",
   "scope": "Main",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5122.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5122.html
index e6fcac91dd..e6b143614d 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5122.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5122.html
@@ -1,78 +1,86 @@
-
            Having a permissive Cross-Origin Resource Sharing policy is security-sensitive. It has led in the past to the following vulnerabilities:
            
-
-
            Same origin policy in browsers prevents, by default and for
-security-reasons, a javascript frontend to perform a cross-origin HTTP request to a resource that has a different origin (domain, protocol, or port)
-from its own. The requested target can append additional HTTP headers in response, called CORS, that act like directives for the browser and change the access control policy
-/ relax the same origin policy.
            
-
            Ask Yourself Whether
            
-
              
-  
            • You don’t trust the origin specified, example: Access-Control-Allow-Origin: untrustedwebsite.com.
              • 
-  
            • Access control policy is entirely disabled: Access-Control-Allow-Origin: *
              • 
-  
            • Your access control policy is dynamically defined by a user-controlled input like origin header.
              • 
-
            
-
            There is a risk if you answered yes to any of those questions.
            
-
            Recommended Secure Coding Practices
            
-
              
-  
            • The Access-Control-Allow-Origin header should be set only for a trusted origin and for specific resources.
              • 
-  
            • Allow only selected, trusted domains in the Access-Control-Allow-Origin header. Prefer whitelisting domains over blacklisting or
-  allowing any domain (do not use * wildcard nor blindly return the Origin header content without any checks).
              • 
-
            
-
            Sensitive Code Example
            
-
            Django:
            
-
            -CORS_ORIGIN_ALLOW_ALL = True # Sensitive
+
            Setting an overly permissive Cross-Origin Resource Sharing (CORS) policy allows malicious websites to read responses from your application on
+behalf of authenticated users.
            
+
            Why is this an issue?
            
+
            Same-origin policy in browsers prevents JavaScript from
+making cross-origin HTTP requests to resources with a different origin (domain, protocol, or port). The Cross-Origin Resource Sharing (CORS) mechanism allows servers to relax this
+restriction by including Access-Control-Allow-Origin response headers that tell browsers which origins are permitted.
            
+
            Setting the Access-Control-Allow-Origin header to a wildcard (*) or dynamically reflecting a user-supplied
+Origin header without validation completely disables same-origin protection for the affected resource.
            
+
            What is the potential impact?
            
+
            Sensitive data exposure
            
+
            When CORS restrictions are disabled, a malicious website visited by an authenticated user can issue cross-origin requests to the vulnerable
+application and read the responses. This allows attackers to steal sensitive data accessible to the victim, such as account details, API keys, or
+private application data.
            
+
            Account takeover
            
+
            If the application is also configured with Access-Control-Allow-Credentials: true, the browser will include cookies and HTTP
+authentication headers in cross-origin requests. Attackers can then perform authenticated operations on behalf of the victim, potentially leading to
+full account takeover or unauthorized data modification.
            
+
            How to fix it in Django
            
+
            Set CORS_ORIGIN_ALLOW_ALL to False and configure specific allowed origins.
            
+
            Code examples
            
+
            Noncompliant code example
            
+
            +CORS_ORIGIN_ALLOW_ALL = True # Noncompliant
 
            
-
            Flask:
            
-
            +
            Compliant solution
            
+
            +CORS_ORIGIN_ALLOW_ALL = False
+
            
+
            How to fix it in Flask
            
+
            Configure the CORS extension with specific allowed origins and validate user-supplied origins against an allow-list.
            
+
            Code examples
            
+
            Noncompliant code example
            
+
             from flask import Flask
 from flask_cors import CORS
 
 app = Flask(__name__)
-CORS(app, resources={r"/*": {"origins": "*", "send_wildcard": "True"}}) # Sensitive
+CORS(app, resources={r"/*": {"origins": "*"}}) # Noncompliant
 
            
 
            User-controlled origin:
            
-
            +
             origin = request.headers['ORIGIN']
 resp = Response()
-resp.headers['Access-Control-Allow-Origin'] = origin # Sensitive
-
            
-
            Compliant Solution
            
-
            Django:
            
-
            -CORS_ORIGIN_ALLOW_ALL = False # Compliant
+resp.headers['Access-Control-Allow-Origin'] = origin # Noncompliant
 
            
-
            Flask:
            
-
            +
            Compliant solution
            
+
             from flask import Flask
 from flask_cors import CORS
 
 app = Flask(__name__)
-CORS(app, resources={r"/*": {"origins": "*", "send_wildcard": "False"}}) # Compliant
+
+TRUSTED_ORIGINS = [
+    "https://example.com",
+]
+
+CORS(app, resources={r"/*": {"origins": TRUSTED_ORIGINS}})
 
            
 
            User-controlled origin validated with an allow-list:
            
-
            +
            +TRUSTED_ORIGINS = ["https://example.com"]
 origin = request.headers['ORIGIN']
 resp = Response()
 if origin in TRUSTED_ORIGINS:
    resp.headers['Access-Control-Allow-Origin'] = origin
 
            
-
            See
            
+
            Resources
            
+
            Documentation
            
+
+
            Standards
            
 
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5122.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5122.json
index 5b1f378f21..bd501a67b5 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5122.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5122.json
@@ -1,19 +1,25 @@
 {
-  "title": "Having a permissive Cross-Origin Resource Sharing policy is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Cross-Origin Resource Sharing (CORS) policy should be restricted to trusted origins",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
-      "SECURITY": "LOW"
+      "SECURITY": "MEDIUM"
     },
     "attribute": "COMPLETE"
   },
   "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "4h"
+  },
+  "quickfix": "unknown",
   "tags": [
     "cwe",
     "django",
-    "flask"
+    "flask",
+    "former-hotspot"
   ],
-  "defaultSeverity": "Minor",
+  "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-5122",
   "sqKey": "S5122",
   "scope": "Main",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5247.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5247.html
index 0e1f647388..3290e1b9f9 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5247.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5247.html
@@ -1,47 +1,42 @@
-
            To reduce the risk of cross-site scripting attacks, templating systems, such as Twig, Django, Smarty,
-Groovy's template engine, allow configuration of automatic variable escaping before rendering templates. When escape occurs, characters
-that make sense to the browser (eg: <a>) will be transformed/replaced with escaped/sanitized values (eg: & lt;a& gt; ).
            
-
            Auto-escaping is not a magic feature to annihilate all cross-site scripting attacks, it depends on the strategy applied and the context, for example a "html auto-escaping" strategy
-(which only transforms html characters into html entities) will not be relevant
-when variables are used in a html attribute because ':' character is not
-escaped and thus an attack as below is possible:
            
-
            -<a href="{{ myLink }}">link</a> // myLink = javascript:alert(document.cookie)
-<a href="javascript:alert(document.cookie)">link</a> // JS injection (XSS attack)
-
            
-
            Ask Yourself Whether
            
-
              
-  
            • Templates are used to render web content and
-    
                
-      
              • dynamic variables in templates come from untrusted locations or are user-controlled inputs
                • 
-      
              • there is no local mechanism in place to sanitize or validate the inputs.
                • 
-    
              • 
-
            
-
            There is a risk if you answered yes to any of those questions.
            
-
            Recommended Secure Coding Practices
            
-
            Enable auto-escaping by default and continue to review the use of inputs in order to be sure that the chosen auto-escaping strategy is the right
-one.
            
-
            Sensitive Code Example
            
-
            +
            Template engines, such as Jinja2, provide automatic escaping of template variables to prevent cross-site scripting (XSS) attacks, but this
+protection can be explicitly disabled.
            
+
            Why is this an issue?
            
+
            Template engines provide auto-escaping as a safety mechanism that transforms HTML special characters in variable output before rendering,
+preventing user-controlled input from being interpreted as HTML or JavaScript by the browser. Disabling this protection — through settings like
+autoescape: false, escape-bypass filters like |safe, or equivalent configuration — allows untrusted input to pass through
+unmodified and be executed by the browser as markup or script.
            
+
            What is the potential impact?
            
+
            When auto-escaping is disabled, an attacker who can control the content of template variables can inject malicious HTML or JavaScript into pages
+served to other users. An attacker could steal session tokens, redirect users to phishing pages, or perform unauthorized actions on behalf of the
+victim.
            
+
            How to fix it
            
+
            Code examples
            
+
            The following examples configure the template engine to disable its auto-escaping feature, allowing template variables to be rendered without HTML
+encoding.
            
+
            Noncompliant code example
            
+
             from jinja2 import Environment
 
-env = Environment() # Sensitive: New Jinja2 Environment has autoescape set to false
-env = Environment(autoescape=False) # Sensitive:
+env = Environment() # Noncompliant: New Jinja2 Environment has autoescape set to false
+env = Environment(autoescape=False) # Noncompliant:
 
            
-
            Compliant Solution
            
-
            +
            Compliant solution
            
+
             from jinja2 import Environment
 env = Environment(autoescape=True) # Compliant
 
            
-
            See
            
+
            Resources
            
+
            Documentation
            
 
+
            Standards
            
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5247.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5247.json
index b3e90ed2af..75b5c0fa76 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5247.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5247.json
@@ -1,6 +1,6 @@
 {
-  "title": "Disabling auto-escaping in template engines is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Auto-escaping in HTML template engines should not be disabled",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
@@ -8,13 +8,15 @@
     "attribute": "COMPLETE"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "5min"
   },
   "tags": [
     "cwe",
-    "django"
+    "django",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-5247",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5300.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5300.html
deleted file mode 100644
index 932a9dd482..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5300.html
+++ /dev/null
@@ -1,71 +0,0 @@
-
            This rule is deprecated, and will eventually be removed.
            
-
            Sending emails is security-sensitive and can expose an application to a large range of vulnerabilities.
            
-
            Information Exposure
            
-
            Emails often contain sensitive information which might be exposed to an attacker if he can add an arbitrary address to the recipient list.
            
-
            Spamming / Phishing
            
-
            Malicious user can abuse email based feature to send spam or phishing content.
            
-
            Dangerous Content Injection
            
-
            Emails can contain HTML and JavaScript code, thus they can be used for XSS attacks.
            
-
            Email Headers Injection
            
-
            Email fields such as subject, to, cc, bcc, from are set in email "headers". 
-Using unvalidated user input to set those fields might allow attackers to inject new line characters in headers to craft malformed SMTP requests.
-Although modern libraries are filtering new line character by default, user data used in email "headers" should always be validated.
            
-
            In the past, it has led to the following vulnerabilities:
            
-
-
            Ask Yourself Whether
            
-
              
-  
            • Unvalidated user input are used to set email headers.
              • 
-  
            • Email content contains data provided by users and it is not sanitized.
              • 
-  
            • Email recipient list or body are based on user inputs.
              • 
-
            
-
            You are at risk if you answered yes to any of those questions.
            
-
            Recommended Secure Coding Practices
            
-
              
-  
            • Use an email library which sanitizes headers (Flask-Mail or django.core.mail).
              • 
-  
            • Use html escape functions to sanitize every piece of data used to in the email body.
              • 
-  
            • Verify application logic to make sure that email base feature can not be abuse to:
-    
                
-      
              • Send arbitrary email for spamming or fishing
                • 
-      
              • Disclose sensitive email content
                • 
-    
              • 
-
            
-
            Sensitive Code Example
            
-
            smtplib
            
-
            -import smtplib
-
-def send(from_email, to_email, msg):
-  server = smtplib.SMTP('localhost', 1025)
-  server.sendmail(from_email, to_email, msg) # Sensitive
-
            
-
            Django
            
-
            -from django.core.mail import send_mail
-
-def send(subject, msg, from_email, to_email):
-  send_mail(subject, msg, from_email, [to_email]) # Sensitive
-
            
-
            Flask-Mail
            
-
            -from flask import Flask
-from flask_mail import Mail, Message
-
-app = Flask(__name__)
-
-def send(subject, msg, from_email, to_email):
-    mail = Mail(app)
-    msg = Message(subject, [to_email], body, sender=from_email)
-    mail.send(msg) # Sensitive
-
            
-
            See
            
-
-
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5300.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5300.json
deleted file mode 100644
index 8bc44c00eb..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5300.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "title": "Sending emails is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
-  "status": "deprecated",
-  "tags": [
-    "deprecated"
-  ],
-  "defaultSeverity": "Critical",
-  "ruleSpecification": "RSPEC-5300",
-  "sqKey": "S5300",
-  "scope": "Main"
-}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5332.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5332.html
index 8c0c9a73f1..af9c36bc37 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5332.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5332.html
@@ -1,75 +1,59 @@
-
            Clear-text protocols such as ftp, telnet, or http lack encryption of transported data, as well as the
-capability to build an authenticated connection. It means that an attacker able to sniff traffic from the network can read, modify, or corrupt the
-transported content. These protocols are not secure as they expose applications to an extensive range of risks:
            
-
              
-  
            • sensitive data exposure
              • 
-  
            • traffic redirected to a malicious endpoint
              • 
-  
            • malware-infected software update or installer
              • 
-  
            • execution of client-side code
              • 
-  
            • corruption of critical information
              • 
-
            
-
            Even in the context of isolated networks like offline environments or segmented cloud environments, the insider threat exists. Thus, attacks
-involving communications being sniffed or tampered with can still happen.
            
-
            For example, attackers could successfully compromise prior security layers by:
            
-
              
-  
            • bypassing isolation mechanisms
              • 
-  
            • compromising a component of the network
              • 
-  
            • getting the credentials of an internal IAM account (either from a service account or an actual person)
              • 
-
            
-
            In such cases, encrypting communications would decrease the chances of attackers to successfully leak data or steal credentials from other network
-components. By layering various security practices (segmentation and encryption, for example), the application will follow the
-defense-in-depth principle.
            
-
            Note that using the http protocol is being deprecated by major web browsers.
            
-
            In the past, it has led to the following vulnerabilities:
            
-
-
            Ask Yourself Whether
            
-
              
-  
            • Application data needs to be protected against falsifications or leaks when transiting over the network.
              • 
-  
            • Application data transits over an untrusted network.
              • 
-  
            • Compliance rules require the service to encrypt data in transit.
              • 
-  
            • Your application renders web pages with a relaxed mixed content policy.
              • 
-  
            • OS-level protections against clear-text traffic are deactivated.
              • 
-
            
-
            There is a risk if you answered yes to any of those questions.
            
-
            Recommended Secure Coding Practices
            
-
              
-  
            • Make application data transit over a secure, authenticated and encrypted protocol like TLS or SSH. Here are a few alternatives to the most
-  common clear-text protocols:
-    
                
-      
              • Use ssh as an alternative to telnet.
                • 
-      
              • Use sftp, scp, or ftps instead of ftp.
                • 
-      
              • Use https instead of http.
                • 
-      
              • Use SMTP over SSL/TLS or SMTP with STARTTLS instead of clear-text SMTP.
                • 
-    
              • 
-  
            • Enable encryption of cloud components communications whenever it is possible.
              • 
-  
            • Configure your application to block mixed content when rendering web pages.
              • 
-  
            • If available, enforce OS-level deactivation of all clear-text traffic.
              • 
-
            
-
            It is recommended to secure all transport channels, even on local networks, as it can take a single non-secure connection to compromise an entire
-application or system.
            
-
            Sensitive Code Example
            
-
            -url = "http://example.com" # Sensitive
-url = "ftp://anonymous@example.com" # Sensitive
-url = "telnet://anonymous@example.com" # Sensitive
+
            Using clear-text protocols exposes data in transit to eavesdropping and man-in-the-middle attacks.
            
+
            Why is this an issue?
            
+
            An attacker who can observe network traffic — for example through a compromised network device, a position on the same network segment, or a cloud
+environment breach — can read, modify, or inject data sent over ftp, telnet, http, or unencrypted SMTP without
+detection. This is true even on internal or isolated networks, where insider threats or lateral movement after an initial compromise can expose
+unencrypted traffic. This rule raises an issue when a clear-text protocol scheme is used or when encryption is explicitly disabled for a network
+connection.
            
+
            What is the potential impact?
            
+
            Sensitive data exposure
            
+
            An attacker who can intercept network traffic can read all data transmitted over clear-text connections, including credentials, session tokens, API
+keys, or personal data.
            
+
            Data tampering
            
+
            Because clear-text protocols provide no integrity protection, an attacker in a man-in-the-middle position can silently modify data in transit —
+redirecting users to malicious endpoints, injecting malicious content into responses, or altering commands sent to remote services.
            
+
            How to fix it in Python Standard Library
            
+
            Code examples
            
+
            The following code uses a clear-text protocol or disables encryption for a network connection, leaving transmitted data exposed to
+interception.
            
+
            Noncompliant code example
            
+
            +url = "http://example.com" # Noncompliant
+url = "ftp://anonymous@example.com" # Noncompliant
+url = "telnet://anonymous@example.com" # Noncompliant
 
 import telnetlib
-cnx = telnetlib.Telnet("towel.blinkenlights.nl") # Sensitive
+cnx = telnetlib.Telnet("telnet.example.com") # Noncompliant
+
+import ftplib
+cnx = ftplib.FTP("ftp.example.com") # Noncompliant
+
+import smtplib
+smtp = smtplib.SMTP("smtp.example.com", port=587) # Noncompliant
+
            
+
            Compliant solution
            
+
            +url = "https://example.com"
+url = "sftp://anonymous@example.com"
+url = "ssh://anonymous@example.com"
 
 import ftplib
-cnx = ftplib.FTP("ftp.example.com") # Sensitive
+cnx = ftplib.FTP_TLS("ftp.example.com")
 
 import smtplib
-smtp = smtplib.SMTP("smtp.example.com", port=587) # Sensitive
+smtp = smtplib.SMTP("smtp.example.com", port=587)
+smtp.starttls(context=context)
+
+smtp_ssl = smtplib.SMTP_SSL("smtp.example.com", port=465)
 
            
+
            How to fix it in AWS Elastic Load Balancing
            
+
            Code examples
            
+
            The following code uses a clear-text protocol or disables encryption for a network connection, leaving transmitted data exposed to
+interception.
            
+
            Noncompliant code example
            
 
            For aws_cdk.aws_elasticloadbalancingv2.ApplicationLoadBalancer:
            
-
            +
             from aws_cdk import (
     aws_elasticloadbalancingv2 as elbv2,
 )
@@ -83,191 +67,62 @@ 
            Sensitive Code Example
            
 
 lb.add_listener(
     "Listener-default",
-    port=80, # Sensitive
+    port=80, # Noncompliant
     open=True
 )
 lb.add_listener(
     "Listener-http-explicit",
-    protocol=elbv2.ApplicationProtocol.HTTP, # Sensitive
+    protocol=elbv2.ApplicationProtocol.HTTP, # Noncompliant
     port=8080,
     open=True
 )
 
            
-
            For aws_cdk.aws_elasticloadbalancingv2.ApplicationListener:
            
-
            +
            Compliant solution
            
+
             from aws_cdk import (
     aws_elasticloadbalancingv2 as elbv2,
 )
 
-elbv2.ApplicationListener(
-    self,
-    "listener-http-explicit-const",
-    load_balancer=lb,
-    protocol=elbv2.ApplicationProtocol.HTTP, # Sensitive
-    port=8081,
-    open=True
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancingv2.NetworkLoadBalancer:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancingv2 as elbv2,
-)
-lb = elbv2.NetworkLoadBalancer(
+lb = elbv2.ApplicationLoadBalancer(
     self,
     "LB",
     vpc=vpc,
     internet_facing=True
 )
 
-lb.add_listener( # Sensitive
-    "Listener-default",
-    port=1234
-)
 lb.add_listener(
-    "Listener-TCP-explicit",
-    protocol=elbv2.Protocol.TCP, # Sensitive
-    port=1337
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancingv2.NetworkListener:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancingv2 as elbv2,
-)
-
-elbv2.NetworkListener(
-    self,
-    "Listener-TCP-explicit",
-    protocol=elbv2.Protocol.TCP, # Sensitive
-    port=1338,
-    load_balancer=lb
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancingv2.CfnListener:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancingv2 as elbv2,
-)
-
-elbv2.CfnListener(
-    self,
-    "listener-http",
-    default_actions=[application_default_action],
-    load_balancer_arn=lb.load_balancer_arn,
-    protocol="HTTP", # Sensitive
-    port=80
-)
-
-elbv2.CfnListener(
-    self,
-    "listener-tcp",
-    default_actions=[network_default_action],
-    load_balancer_arn=lb.load_balancer_arn,
-    protocol="TCP", # Sensitive
-    port=1000
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancing.LoadBalancerListener:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancing as elb,
-)
-
-elb.LoadBalancerListener(
-    external_port=10000,
-    external_protocol=elb.LoadBalancingProtocol.TCP, # Sensitive
-    internal_port=10000
-)
-
-elb.LoadBalancerListener(
-    external_port=10080,
-    external_protocol=elb.LoadBalancingProtocol.HTTP, # Sensitive
-    internal_port=10080
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancing.CfnLoadBalancer:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancing as elb
-)
-
-elb.CfnLoadBalancer(
-    self,
-    "elb-tcp",
-    listeners=[
-        elb.CfnLoadBalancer.ListenersProperty(
-            instance_port="10000",
-            load_balancer_port="10000",
-            protocol="tcp" # Sensitive
-        )
-    ],
-    subnets=vpc.select_subnets().subnet_ids
-)
-
-elb.CfnLoadBalancer(
-    self,
-    "elb-http-dict",
-    listeners=[
-        {
-            "instancePort":"10000",
-            "loadBalancerPort":"10000",
-            "protocol":"http" # Sensitive
-        }
-    ],
-    subnets=vpc.select_subnets().subnet_ids
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancing.LoadBalancer:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancing as elb,
-)
-
-elb.LoadBalancer(
-    self,
-    "elb-tcp-dict",
-    vpc=vpc,
-    listeners=[
-        {
-            "externalPort":10000,
-            "externalProtocol":elb.LoadBalancingProtocol.TCP, # Sensitive
-            "internalPort":10000
-        }
-    ]
+    "Listener-https-explicit",
+    protocol=elbv2.ApplicationProtocol.HTTPS,
+    certificates=[elbv2.ListenerCertificate("certificateARN")],
+    port=443,
+    open=True
 )
 
-loadBalancer.add_listener(
-    external_port=10081,
-    external_protocol=elb.LoadBalancingProtocol.HTTP, # Sensitive
-    internal_port=10081
-)
-loadBalancer.add_listener(
-    external_port=10001,
-    external_protocol=elb.LoadBalancingProtocol.TCP, # Sensitive
-    internal_port=10001
+lb.add_listener(
+    "Listener-https-implicit",
+    certificates=[elbv2.ListenerCertificate("certificateARN")],
+    port=8443,
+    open=True
 )
 
            
+
            How to fix it in Amazon ElastiCache
            
+
            Code examples
            
+
            The following code uses a clear-text protocol or disables encryption for a network connection, leaving transmitted data exposed to
+interception.
            
+
            Noncompliant code example
            
 
            For aws_cdk.aws_elasticache.CfnReplicationGroup:
            
-
            +
             from aws_cdk import (
     aws_elasticache as elasticache
 )
 
 elasticache.CfnReplicationGroup(
     self,
-    "unencrypted-explicit",
+    "example-explicit",
     replication_group_description="a replication group",
     automatic_failover_enabled=False,
-    transit_encryption_enabled=False, # Sensitive
+    transit_encryption_enabled=False, # Noncompliant
     cache_subnet_group_name="test",
     engine="redis",
     engine_version="3.2.6",
@@ -275,11 +130,30 @@ 
            Sensitive Code Example
            
     cache_node_type="cache.t2.micro"
 )
 
-elasticache.CfnReplicationGroup( # Sensitive, encryption is disabled by default
+elasticache.CfnReplicationGroup( # Noncompliant: encryption is disabled by default
     self,
-    "unencrypted-implicit",
+    "example-implicit",
+    replication_group_description="a replication group",
+    automatic_failover_enabled=False,
+    cache_subnet_group_name="test",
+    engine="redis",
+    engine_version="3.2.6",
+    num_cache_clusters=1,
+    cache_node_type="cache.t2.micro"
+)
+
            
+
            Compliant solution
            
+
            +from aws_cdk import (
+    aws_elasticache as elasticache
+)
+
+elasticache.CfnReplicationGroup(
+    self,
+    "example-explicit",
     replication_group_description="a test replication group",
     automatic_failover_enabled=False,
+    transit_encryption_enabled=True,
     cache_subnet_group_name="test",
     engine="redis",
     engine_version="3.2.6",
@@ -287,318 +161,58 @@ 
            Sensitive Code Example
            
     cache_node_type="cache.t2.micro"
 )
 
            
+
            How to fix it in AWS Kinesis
            
+
            Code examples
            
+
            The following code uses a clear-text protocol or disables encryption for a network connection, leaving transmitted data exposed to
+interception.
            
+
            Noncompliant code example
            
 
            For aws_cdk.aws_kinesis.CfnStream:
            
-
            +
             from aws_cdk import (
     aws_kinesis as kinesis,
 )
 
-kinesis.CfnStream( # Sensitive, encryption is disabled by default for CfnStreams
+kinesis.CfnStream( # Noncompliant: encryption is disabled by default for CfnStreams
     self,
-    "cfnstream-implicit-unencrytped",
+    "example-cfnstream-implicit",
     shard_count=1
 )
 
 kinesis.CfnStream(self,
-    "cfnstream-explicit-unencrytped",
+    "example-cfnstream-explicit",
     shard_count=1,
-    stream_encryption=None # Sensitive
+    stream_encryption=None # Noncompliant
 )
 
            
 
            For aws_cdk.aws_kinesis.Stream:
            
-
            +
             from aws_cdk import (
     aws_kinesis as kinesis,
 )
 
 stream = kinesis.Stream(self,
-    "stream-explicit-unencrypted",
+    "example-stream",
     shard_count=1,
-    encryption=kinesis.StreamEncryption.UNENCRYPTED # Sensitive
-)
-
            
-
            Compliant Solution
            
-
            -url = "https://example.com"
-url = "sftp://anonymous@example.com"
-url = "ssh://anonymous@example.com"
-
-import ftplib
-cnx = ftplib.FTP_TLS("ftp.example.com")
-
-import smtplib
-smtp = smtplib.SMTP("smtp.example.com", port=587)
-smtp.starttls(context=context)
-
-smtp_ssl = smtplib.SMTP_SSL("smtp.gmail.com", port=465)
-
            
-
            For aws_cdk.aws_elasticloadbalancingv2.ApplicationLoadBalancer:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancingv2 as elbv2,
-)
-
-lb = elbv2.ApplicationLoadBalancer(
-    self,
-    "LB",
-    vpc=vpc,
-    internet_facing=True
-)
-
-lb.add_listener(
-    "Listener-https-explicit",
-    protocol=elbv2.ApplicationProtocol.HTTPS,
-    certificates=[elbv2.ListenerCertificate("certificateARN")],
-    port=443,
-    open=True
-)
-
-lb.add_listener(
-    "Listener-https-implicit",
-    certificates=[elbv2.ListenerCertificate("certificateARN")],
-    port=8443,
-    open=True
-)
-
            
-
            For 
-aws_cdk.aws_elasticloadbalancingv2.ApplicationListener:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancingv2 as elbv2,
-)
-
-elbv2.ApplicationListener(
-    self,
-    "listener-https-explicit-const",
-    load_balancer=lb,
-    protocol=elbv2.ApplicationProtocol.HTTPS,
-    certificates=[elbv2.ListenerCertificate("certificateARN")],
-    port=444,
-    open=True
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancingv2.NetworkLoadBalancer:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancingv2 as elbv2,
-)
-lb = elbv2.NetworkLoadBalancer(
-    self,
-    "LB",
-    vpc=vpc,
-    internet_facing=True
-)
-
-lb.add_listener(
-    "Listener-TLS-explicit",
-    protocol=elbv2.Protocol.TLS,
-    certificates=[elbv2.ListenerCertificate("certificateARN")],
-    port=443
-)
-lb.add_listener(
-    "Listener-TLS-implicit",
-    certificates=[elbv2.ListenerCertificate("certificateARN")],
-    port=1024
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancingv2.NetworkListener:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancingv2 as elbv2,
-)
-
-elbv2.NetworkListener(
-    self,
-    "Listener-TLS-explicit",
-    protocol=elbv2.Protocol.TLS,
-    certificates=[elbv2.ListenerCertificate("certificateARN")],
-    port=443,
-    load_balancer=lb
+    encryption=kinesis.StreamEncryption.UNENCRYPTED # Noncompliant
 )
 
            
-
            For aws_cdk.aws_elasticloadbalancingv2.CfnListener:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancingv2 as elbv2,
-)
-
-elbv2.CfnListener(
-    self,
-    "listener-https",
-    default_actions=[application_default_action],
-    load_balancer_arn=lb.load_balancer_arn,
-    protocol="HTTPS",
-    port=443,
-    certificates=[elbv2.CfnListener.CertificateProperty(
-        certificate_arn="certificateARN"
-    )]
-)
-
-elbv2.CfnListener(
-    self,
-    "listener-tls",
-    default_actions=[network_default_action],
-    load_balancer_arn=lb.load_balancer_arn,
-    protocol="TLS",
-    port=1001,
-    certificates=[elbv2.CfnListener.CertificateProperty(
-        certificate_arn="certificateARN"
-    )]
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancing.LoadBalancerListener:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancing as elb,
-)
-
-elb.LoadBalancerListener(
-    external_port=10043,
-    external_protocol=elb.LoadBalancingProtocol.SSL,
-    internal_port=10043,
-    ssl_certificate_arn="certificateARN"
-)
-
-elb.LoadBalancerListener(
-    external_port=10443,
-    external_protocol=elb.LoadBalancingProtocol.HTTPS,
-    internal_port=10443,
-    ssl_certificate_arn="certificateARN"
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancing.CfnLoadBalancer:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancing as elb,
-)
-
-elb.CfnLoadBalancer(
-    self,
-    "elb-ssl",
-    listeners=[
-        elb.CfnLoadBalancer.ListenersProperty(
-            instance_port="10043",
-            load_balancer_port="10043",
-            protocol="ssl",
-            ssl_certificate_id=CERTIFICATE_ARN
-        )
-    ],
-    subnets=vpc.select_subnets().subnet_ids
-)
-
-elb.CfnLoadBalancer(
-    self,
-    "elb-https-dict",
-    listeners=[
-        {
-            "instancePort":"10443",
-            "loadBalancerPort":"10443",
-            "protocol":"https",
-            "sslCertificateId":CERTIFICATE_ARN
-        }
-    ],
-    subnets=vpc.select_subnets().subnet_ids
-)
-
            
-
            For aws_cdk.aws_elasticloadbalancing.LoadBalancer:
            
-
            -from aws_cdk import (
-    aws_elasticloadbalancing as elb,
-)
-
-elb.LoadBalancer(
-    self,
-    "elb-ssl",
-    vpc=vpc,
-    listeners=[
-        {
-            "externalPort":10044,
-            "externalProtocol":elb.LoadBalancingProtocol.SSL,
-            "internalPort":10044,
-            "sslCertificateArn":"certificateARN"
-        },
-        {
-            "externalPort":10444,
-            "externalProtocol":elb.LoadBalancingProtocol.HTTPS,
-            "internalPort":10444,
-            "sslCertificateArn":"certificateARN"
-        }
-    ]
-)
-
-loadBalancer = elb.LoadBalancer(
-        self,
-        "elb-multi-listener",
-        vpc=vpc
-)
-loadBalancer.add_listener(
-    external_port=10045,
-    external_protocol=elb.LoadBalancingProtocol.SSL,
-    internal_port=10045,
-    ssl_certificate_arn="certificateARN"
-)
-loadBalancer.add_listener(
-    external_port=10445,
-    external_protocol=elb.LoadBalancingProtocol.HTTPS,
-    internal_port=10445,
-    ssl_certificate_arn="certificateARN"
-)
-
            
-
            For aws_cdk.aws_elasticache.CfnReplicationGroup:
            
-
            -from aws_cdk import (
-    aws_elasticache as elasticache
-)
-
-elasticache.CfnReplicationGroup(
-    self,
-    "encrypted-explicit",
-    replication_group_description="a test replication group",
-    automatic_failover_enabled=False,
-    transit_encryption_enabled=True,
-    cache_subnet_group_name="test",
-    engine="redis",
-    engine_version="3.2.6",
-    num_cache_clusters=1,
-    cache_node_type="cache.t2.micro"
-)
-
            
-
            For aws_cdk.aws_kinesis.CfnStream:
            
-
            +
            Compliant solution
            
+
             from aws_cdk import (
     aws_kinesis as kinesis,
 )
 
 kinesis.CfnStream(
     self,
-    "cfnstream-explicit-encrytped",
+    "example-cfnstream-explicit",
     shard_count=1,
     stream_encryption=kinesis.CfnStream.StreamEncryptionProperty(
         encryption_type="KMS",
         key_id="alias/aws/kinesis"
     )
 )
-
-stream = kinesis.CfnStream(
-    self,
-    "cfnstream-explicit-encrytped-dict",
-    shard_count=1,
-    stream_encryption={
-        "encryptionType": "KMS",
-        "keyId": "alias/aws/kinesis"
-    }
-)
 
            
-
            For aws_cdk.aws_kinesis.Stream:
            
-
            +
             from aws_cdk import (
     aws_kinesis as kinesis,
     aws_kms as kms
@@ -606,32 +220,28 @@ 
            Compliant Solution
            
 
 stream = kinesis.Stream( # Encryption is enabled by default for Streams
     self,
-    "stream-implicit-encrypted",
+    "example-stream",
     shard_count=1
 )
 
 stream = kinesis.Stream(
     self,
-    "stream-explicit-encrypted-managed",
+    "example-stream-managed",
     shard_count=1,
     encryption=kinesis.StreamEncryption.MANAGED
 )
-
-key = kms.Key(self, "managed_key")
-stream = kinesis.Stream(
-    self,
-    "stream-explicit-encrypted-selfmanaged",
-    shard_count=1,
-    encryption=kinesis.StreamEncryption.KMS,
-    encryption_key=key
-)
 
            
 
            Exceptions
            
-
            No issue is reported for the following cases because they are not considered sensitive:
            
+
            No issue is reported for the following cases:
            
 
              
-  
            • Insecure protocol scheme followed by loopback addresses like 127.0.0.1 or localhost.
              • 
+  
            • URLs whose host resolves only within a private runtime environment and is not reachable from the public internet (including loopback and cloud
+  metadata hosts)
              • 
+  
            • Well-known namespace URI authorities used in in XML, JSON-LD, RDF, or similar formats (for example, www.w3.org,
+  schemas.android.com, schema.org).
              • 
+  
            • IANA-reserved documentation and test domains like example.com, example.net, example.org (RFC 6761). These
+  are almost always placeholders in source code, not real connection targets.
              • 
 
            
-
            See
            
+
            Resources
            
 
            Documentation
            
 
-
            It is also possible to use AES-CBC with HMAC for integrity checks. However, it is considered more straightforward to use AES-GCM directly
-instead.
            
 
            For RSA: use the OAEP scheme
            
 
            The Optimal Asymmetric Encryption Padding scheme (OAEP) adds randomness and a secure hash function that strengthens the regular inner workings of
 RSA.
            
@@ -162,8 +158,6 @@ 
            For AES: use authenticated encryption modes
            
   
          • IAPM: Integer Authenticated Parallelizable Mode
            • 
   
          • OCB: Offset Codebook Mode
            • 
 
          
-
          It is also possible to use AES-CBC with HMAC for integrity checks. However, it is considered more straightforward to use AES-GCM directly
-instead.
          
 
          For RSA: use the OAEP scheme
          
 
          The Optimal Asymmetric Encryption Padding scheme (OAEP) adds randomness and a secure hash function that strengthens the regular inner workings of
 RSA.
          
@@ -214,8 +208,6 @@ 
          For AES: use authenticated encryption modes
          
   
        • IAPM: Integer Authenticated Parallelizable Mode
          • 
   
        • OCB: Offset Codebook Mode
          • 
 
        
-
        It is also possible to use AES-CBC with HMAC for integrity checks. However, it is considered more straightforward to use AES-GCM directly
-instead.
        
 
        For RSA: use the OAEP scheme
        
 
        The Optimal Asymmetric Encryption Padding scheme (OAEP) adds randomness and a secure hash function that strengthens the regular inner workings of
 RSA.
        
@@ -254,16 +246,12 @@ 
        For AES: use authenticated encryption modes
        
   
      • IAPM: Integer Authenticated Parallelizable Mode
        • 
   
      • OCB: Offset Codebook Mode
        • 
 
      
-
      It is also possible to use AES-CBC with HMAC for integrity checks. However, it is considered more straightforward to use AES-GCM directly
-instead.
      
 
      For RSA: use the OAEP scheme
      
 
      The Optimal Asymmetric Encryption Padding scheme (OAEP) adds randomness and a secure hash function that strengthens the regular inner workings of
 RSA.
      
 
      Resources
      
 
      Articles & blog posts
      
 
        
-  
      • Microsoft, Timing vulnerabilities with CBC-mode
-  symmetric decryption using padding
        • 
   
      • Wikipedia, Padding Oracle Attack
        • 
   
      • Wikipedia, Chosen-Ciphertext Attack
        • 
   
      • Wikipedia, Chosen-Plaintext Attack
        • 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5778.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5778.html
new file mode 100644
index 0000000000..e5ffa8f317
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5778.html
@@ -0,0 +1,72 @@
+
        This rule raises an issue when a test for an expected exception contains multiple method calls, making it unclear which call is expected to raise
+the exception.
        
+
        Why is this an issue?
        
+
        When writing tests for exception handling, clarity is essential. If you chain multiple method calls within the code being tested for an exception,
+it becomes ambiguous which specific call is expected to raise that exception.
        
+
        For example, both parse_payment(payload) and normalize() could raise a ValueError:
        
+
        +with pytest.raises(ValueError):
+    parse_payment(payload).normalize()
+
        
+
        The test does not make it explicit which method is expected to raise the exception. This ambiguity makes the test harder to read and maintain.
        
+
        By isolating the method call you want to test, you make your test explicit and unambiguous. This improves readability and maintainability, and
+makes your test suite a better specification of expected behavior.
        
+
        What is the potential impact?
        
+
        Writing tests with multiple method calls when testing for exceptions reduces test quality:
        
+
          
+  
        • Incorrect test coverage: You may think you’re testing one method’s exception behavior when you’re actually testing
+  another’s.
          • 
+  
        • Maintenance burden: Other developers (or future you) will struggle to understand what the test is verifying.
          • 
+  
        • Reduced confidence: Passing tests don’t guarantee that the specific behavior you intended to test is working correctly.
          • 
+
        
+
        How to fix it in pytest
        
+
        When using pytest’s pytest.raises() context manager, extract intermediate method calls into separate variables before the assertion.
+This ensures only the final method call that you want to test is inside the exception-testing block.
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +import pytest
+
+def test_normalize_rejects_negative_amount():
+    with pytest.raises(ValueError):  # Noncompliant
+        parse_payment(payload).normalize()
+
        
+
        Compliant solution
        
+
        +import pytest
+
+def test_normalize_rejects_negative_amount():
+    payment = parse_payment(payload)
+    with pytest.raises(ValueError):
+        payment.normalize()
+
        
+
        How to fix it in unittest
        
+
        When using unittest’s assertRaises() method, extract intermediate method calls before the assertion. This makes it clear which
+specific method is being tested for the exception.
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +import unittest
+
+class TestPayment(unittest.TestCase):
+    def test_normalize_rejects_negative_amount(self):
+        self.assertRaises(ValueError, lambda: parse_payment(payload).normalize())  # Noncompliant
+
        
+
        Compliant solution
        
+
        +import unittest
+
+class TestPayment(unittest.TestCase):
+    def test_normalize_rejects_negative_amount(self):
+        payment = parse_payment(payload)
+        self.assertRaises(ValueError, payment.normalize)
+
        
+
        Resources
        
+
        Documentation
        
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5778.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5778.json
new file mode 100644
index 0000000000..b88c4c6bd6
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5778.json
@@ -0,0 +1,25 @@
+{
+  "title": "Only one method invocation is expected when testing runtime exceptions",
+  "type": "CODE_SMELL",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  },
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "unittest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-5778",
+  "sqKey": "S5778",
+  "scope": "Tests",
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5779.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5779.html
new file mode 100644
index 0000000000..a6e4c24240
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5779.html
@@ -0,0 +1,191 @@
+
        This rule raises an issue when assertion statements, assertion methods, or fluent assertions are placed within a try block that catches
+AssertionError exceptions without properly handling or re-raising them.
        
+
        Why is this an issue?
        
+
        Assertions in Python raise an AssertionError when they fail. This includes built-in assert statements,
+unittest assertion helpers such as assertEqual, and fluent assertions from libraries such as assertpy. This is
+the mechanism testing frameworks use to detect test failures.
        
+
        When you place assertions within a try-except block that catches AssertionError (or its parent class Exception), and you
+do not re-raise the exception or validate its properties, you create a silent failure scenario. The assertion can fail, but the exception gets
+swallowed by the except block, causing the test to pass when it should have failed.
        
+
        This defeats the entire purpose of writing assertions in tests. The test appears to pass, giving false confidence that the code works correctly,
+when in reality the assertion failed and detected a problem.
        
+
        The root cause of this anti-pattern is usually a misunderstanding of exception handling in tests. Developers might add try-except blocks around
+assertions thinking they need to "handle" exceptions, but assertions are meant to propagate upward to the test framework.
        
+
        This issue commonly occurs when:
        
+
          
+  
        • Developers are testing code that raises exceptions and incorrectly wrap assertions in try-except blocks
          • 
+  
        • Code is copied from production exception handling patterns and applied inappropriately in tests
          • 
+  
        • Developers want to add context to assertion failures but do so incorrectly
          • 
+  
        • Fluent assertions from libraries such as assertpy are treated like ordinary code inside a try-except AssertionError
+  block
          • 
+
        
+
        What is the potential impact?
        
+
        When assertions are silently caught and ignored, tests provide false confidence in the codebase. Code that should fail tests will appear to pass,
+allowing bugs to reach production.
        
+
        This can lead to:
        
+
          
+  
        • Security vulnerabilities going undetected if security-related tests falsely pass
          • 
+  
        • Functional bugs making it to production
          • 
+  
        • Regression of previously working features without detection
          • 
+  
        • Wasted debugging time when issues are discovered later in the development cycle or in production
          • 
+  
        • Loss of trust in the test suite’s reliability
          • 
+
        
+
        How to fix it in unittest
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        The assertion (self.fail(…​)) raises an AssertionError, which is immediately caught by the surrounding except
+AssertionError block and silently discarded. As a result, the test can never fail, even when do_something() does not behave as
+expected.
        
+
        +import unittest
+
+class MyTest(unittest.TestCase):
+    def test_should_raise_error(self):
+        try:
+            self.do_something()
+            self.fail("Expected an AssertionError!")  # Noncompliant
+        except AssertionError:
+            pass
+
+    def do_something(self):
+        raise AssertionError("Something went wrong")
+
        
+
        This variation has the same problem: the AssertionError is caught locally and ignored. The test appears to check the exception
+details, but it never validates anything about the caught error.
        
+
        +import unittest
+
+class MyTest(unittest.TestCase):
+    def test_error_message(self):
+        try:
+            self.do_something()
+            self.fail("Expected an AssertionError!")  # Noncompliant
+        except AssertionError:
+            pass  # Exception caught but not validated
+
+    def do_something(self):
+        raise AssertionError("Something went wrong")
+
        
+
        Compliant solution
        
+
        Use the proper assertion context managers provided by the testing framework. The assertRaises context manager is designed specifically
+for testing that exceptions are raised, without accidentally catching assertion failures.
        
+
        +import unittest
+
+class MyTest(unittest.TestCase):
+    def test_should_raise_error(self):
+        with self.assertRaises(AssertionError):
+            self.do_something()
+
+    def do_something(self):
+        raise AssertionError("Something went wrong")
+
        
+
        If you need to verify specific properties of the exception, you can access the exception object through the context manager and make assertions
+about it after the context exits. This ensures the exception is properly raised while still allowing you to validate its details.
        
+
        +import unittest
+
+class MyTest(unittest.TestCase):
+    def test_error_message(self):
+        with self.assertRaises(AssertionError) as context:
+            self.do_something()
+
+        self.assertEqual(str(context.exception), "Something went wrong")
+
+    def do_something(self):
+        raise AssertionError("Something went wrong")
+
        
+
        How to fix it in pytest
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        The assert False statement raises an AssertionError, which is then swallowed by the surrounding except
+AssertionError block. Because of that, the test can never fail when do_something() does not raise the expected error.
        
+
        +import pytest
+
+def test_should_raise_error():
+    try:
+        do_something()
+        assert False, "Expected an AssertionError!"  # Noncompliant
+    except AssertionError:
+        pass
+
+def do_something():
+    raise AssertionError("Something went wrong")
+
        
+
        Here too, the caught AssertionError is never validated or re-raised. The test silently succeeds instead of checking that the expected
+failure really happened.
        
+
        +import pytest
+
+def test_error_details():
+    try:
+        do_something()
+        assert False, "Expected an AssertionError!"  # Noncompliant
+    except AssertionError:
+        pass  # Exception details not validated
+
+def do_something():
+    raise AssertionError("Something went wrong")
+
        
+
        Compliant solution
        
+
        When using pytest, use the pytest.raises context manager to properly test for exceptions. This ensures that assertion failures are not
+accidentally caught.
        
+
        +import pytest
+
+def test_should_raise_error():
+    with pytest.raises(AssertionError):
+        do_something()
+
+def do_something():
+    raise AssertionError("Something went wrong")
+
        
+
        To validate specific exception properties with pytest, access the exception info from the context manager. You can then make assertions about the
+exception message or other attributes.
        
+
        +import pytest
+
+def test_error_details():
+    with pytest.raises(AssertionError) as exc_info:
+        do_something()
+
+    assert str(exc_info.value) == "Something went wrong"
+
+def do_something():
+    raise AssertionError("Something went wrong")
+
        
+
        How to fix it in assertpy
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        With assertpy, fluent assertions still raise AssertionError. Catching that exception in the surrounding
+try-except block can hide a failing test.
        
+
        +from assertpy import assert_that
+
+def test_result():
+    try:
+        result = get_result()
+        assert_that(result).is_equal_to("expected")  # Noncompliant
+    except AssertionError:
+        pass
+
        
+
        Compliant solution
        
+
        Keep the assertpy assertion outside the try-except block so test failures are reported normally.
        
+
        +from assertpy import assert_that
+
+def test_result():
+    result = get_result()
+    assert_that(result).is_equal_to("expected")
+
        
+
        Resources
        
+
        Documentation
        
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5779.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5779.json
new file mode 100644
index 0000000000..a67a3c56e4
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5779.json
@@ -0,0 +1,26 @@
+{
+  "title": "Assertions should not be made within the try block of a try-except catching AssertionError",
+  "type": "BUG",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  },
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "tests",
+    "assertpy",
+    "pytest",
+    "unittest"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-5779",
+  "sqKey": "S5779",
+  "scope": "Tests",
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5852.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5852.html
index 4c393904d7..071ee23aa7 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5852.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5852.html
@@ -1,69 +1,63 @@
-
        Most of the regular expression engines use backtracking to try all possible execution paths of the regular expression when evaluating
-an input, in some cases it can cause performance issues, called catastrophic backtracking situations. In the worst case, the complexity
-of the regular expression is exponential in the size of the input, this means that a small carefully-crafted input (like 20 chars) can trigger
-catastrophic backtracking and cause a denial of service of the application. Super-linear regex complexity can lead to the same impact too
-with, in this case, a large carefully-crafted input (thousands chars).
        
-
        This rule determines the runtime complexity of a regular expression and informs you of the complexity if it is not linear.
        
-
        Ask Yourself Whether
        
+
        Regular expression engines rely on backtracking to evaluate patterns against input. Certain regex patterns lead to catastrophic backtracking, where
+the evaluation time grows exponentially with the input size.
        
+
        Why is this an issue?
        
+
        Regular expression engines use backtracking to try all possible execution paths when evaluating a pattern against an input. In some cases, this
+leads to catastrophic backtracking situations where the worst-case evaluation time grows exponentially with the input size. A small, carefully crafted
+input (around 20 characters) can trigger exponential backtracking and cause a denial of service of the application.
        
+
        This rule reports regular expressions that create exponential backtracking.
        
+
        What is the potential impact?
        
+
        Denial of service
        
+
        An attacker who can control the input matched against a vulnerable regular expression can craft a payload that causes the regex engine to explore
+an exponential number of execution paths. This causes the matching thread to consume excessive CPU time, preventing the application from serving
+legitimate users.
        
+
        How to fix it
        
+
        To fix a vulnerable regular expression, consider the following strategies:
        
 
          
-  
        • The input is user-controlled.
          • 
-  
        • The input size is not restricted to a small number of characters.
          • 
-  
        • There is no timeout in place to limit the regex evaluation time.
          • 
+  
        • Use possessive quantifiers and atomic grouping (available since Python 3.11) to prevent the regex engine from keeping backtracking
+  positions.
          • 
+  
        • Replace . with negated character classes to exclude separators where applicable (e.g., 
+  instead of . before ).
          • 
+  
        • Use bounded quantifiers such as {1,5} to limit repetitions.
          • 
+  
        • Restructure nested quantifiers so the inner group can match in only one way.
          • 
 
        
-
        There is a risk if you answered yes to any of those questions.
        
-
        Recommended Secure Coding Practices
        
-
        To avoid catastrophic backtracking situations, make sure that none of the following conditions apply to your regular expression.
        
-
        In all of the following cases, catastrophic backtracking can only happen if the problematic part of the regex is followed by a pattern that can
-fail, causing the backtracking to actually happen. Note that when performing a full match (e.g. using re.fullmatch), the end of the regex
-counts as a pattern that can fail because it will only succeed when the end of the string is reached.
        
-
          
-  
        • If you have a non-possessive repetition r* or r*?, such that the regex r could produce different possible
-  matches (of possibly different lengths) on the same input, the worst case matching time can be exponential. This can be the case if r
-  contains optional parts, alternations or additional repetitions (but not if the repetition is written in such a way that there’s only one way to
-  match it).
          • 
-  
        • If you have multiple non-possessive repetitions that can match the same contents and are consecutive or are only separated by an optional
-  separator or a separator that can be matched by both of the repetitions, the worst case matching time can be polynomial (O(n^c) where c is the
-  number of problematic repetitions). For example a*b* is not a problem because a* and b* match different
-  things and a*_a* is not a problem because the repetitions are separated by a '_' and can’t match that '_'.
-  However, a*a* and .*_.* have quadratic runtime.
          • 
-  
        • If you’re performing a partial match (such as by using re.search, re.split, re.findall etc.) and the
-  regex is not anchored to the beginning of the string, quadratic runtime is especially hard to avoid because whenever a match fails, the regex engine
-  will try again starting at the next index. This means that any unbounded repetition (even a possessive one), if it’s followed by a pattern that can
-  fail, can cause quadratic runtime on some inputs. For example re.split(r"\s*,", my_str) will run in quadratic time on strings that
-  consist entirely of spaces (or at least contain large sequences of spaces, not followed by a comma).
          • 
-
        
-
        In order to rewrite your regular expression without these patterns, consider the following strategies:
        
-
          
-  
        • If applicable, define a maximum number of expected repetitions using the bounded quantifiers, like {1,5} instead of +
-  for instance.
          • 
-  
        • Refactor nested quantifiers to limit the number of way the inner group can be matched by the outer quantifier, for instance this
-  nested quantifier situation (ba+)+ doesn’t cause performance issues, indeed, the inner group can be matched only if there exists
-  exactly one b char per repetition of the group.
          • 
-  
        • Optimize regular expressions with possessive quantifiers and atomic grouping (available since Python 3.11).
          • 
-  
        • Use negated character classes instead of . to exclude separators where applicable. For example the quadratic regex
-  .*_.* can be made linear by changing it to [^_]*_.*
          • 
-
        
-
        Sometimes it’s not possible to rewrite the regex to be linear while still matching what you want it to match. Especially when using partial
-matches, for which it is quite hard to avoid quadratic runtimes. In those cases consider the following approaches:
        
-
          
-  
        • Solve the problem without regular expressions
          • 
-  
        • Use an alternative non-backtracking regex implementations such as Google’s RE2.
          • 
-  
        • Use multiple passes. This could mean pre- and/or post-processing the string manually before/after applying the regular expression to it or using
-  multiple regular expressions. One example of this would be to replace re.split("\s*,\s*", my_str) with re.split(",",
-  my_str) and then trimming the spaces from the strings as a second step.
          • 
-
        
-
        See
        
+
        Code examples
        
+
        The following regular expression is vulnerable to exponential backtracking and will never terminate for the given input.
        
+
        Noncompliant code example
        
+
        +import re
+
+re.search(r"(a+)+$", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
+                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
+                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
+                      "aaaaaaaaaaaaaaa!")  # Noncompliant
+
        
+
        Compliant solution
        
+
        Using atomic grouping (available since Python 3.11) prevents the engine from keeping backtracking positions:
        
+
        +import re
+
+re.search(r"(?>a+)+$", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
+                        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
+                        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
+                        "aaaaaaaaaaaaaaa!")
+
        
+
        Resources
        
+
        Articles & blog posts
        
 
+
        Standards
        
+
+
        Related rules
        
+
          
+  
        • {rule:python:S8786} - Regular expressions should not cause non-linear backtracking
          • 
 
        
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5852.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5852.json
index 8051ec85b5..c11030bd74 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5852.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5852.json
@@ -1,6 +1,6 @@
 {
-  "title": "Using slow regular expressions is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Regular expressions should not cause catastrophic backtracking",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "HIGH"
@@ -8,13 +8,15 @@
     "attribute": "EFFICIENT"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "30min"
   },
   "tags": [
     "cwe",
-    "regex"
+    "regex",
+    "former-hotspot"
   ],
   "defaultSeverity": "Critical",
   "ruleSpecification": "RSPEC-5852",
@@ -22,11 +24,10 @@
   "scope": "All",
   "securityStandards": {
     "CWE": [
-      400,
       1333
     ],
-    "OWASP": [
-      "A1"
+    "OWASP Top 10 2021": [
+      "A4"
     ],
     "ASVS 4.0": [
       "12.1.1"
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5863.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5863.html
new file mode 100644
index 0000000000..6bebe722b2
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5863.html
@@ -0,0 +1,92 @@
+
        This rule raises an issue when the actual expression of an assertion matches the expected expression, meaning the same expression is being compared
+to itself.
        
+
        Why is this an issue?
        
+
        Assertions that compare the same expression to itself provide no meaningful validation. They usually indicate a copy-paste mistake where the
+intended expected value was replaced by the actual one.
        
+
        Such assertions will always pass, or always fail for inequality checks, regardless of the code’s correctness. As a result, the test gives false
+confidence while verifying nothing useful.
        
+
        How to fix it in unittest
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +import unittest
+
+class TestCalculation(unittest.TestCase):
+    def test_addition(self):
+        result = 2 + 2
+        self.assertEqual(result, result)  # Noncompliant
+
        
+
        For identity checks using assertIs, ensure you’re comparing against a different expected object, not the same one.
        
+
        +import unittest
+
+class TestIdentity(unittest.TestCase):
+    def test_singleton(self):
+        obj = get_singleton()
+        self.assertIs(obj, obj)  # Noncompliant
+
        
+
        Compliant solution
        
+
        Replace the duplicate argument with the intended expected value.
        
+
        +import unittest
+
+class TestCalculation(unittest.TestCase):
+    def test_addition(self):
+        result = 2 + 2
+        expected = 4
+        self.assertEqual(result, expected)
+
        
+
        For identity checks using assertIs, compare against a different expected object.
        
+
        +import unittest
+
+class TestIdentity(unittest.TestCase):
+    def test_singleton(self):
+        obj1 = get_singleton()
+        obj2 = get_singleton()
+        self.assertIs(obj1, obj2)
+
        
+
        How to fix it in pytest
        
+
        Replace the duplicate argument with the intended expected value.
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +def test_string_conversion():
+    actual = str(42)
+    assert actual == actual  # Noncompliant
+
        
+
        Compliant solution
        
+
        +def test_string_conversion():
+    actual = str(42)
+    expected = "42"
+    assert actual == expected
+
        
+
        How to fix it in assertpy
        
+
        Replace the duplicate argument with the intended expected value.
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +from assertpy import assert_that
+
+def test_string_conversion():
+    actual = str(42)
+    assert_that(actual).is_equal_to(actual)  # Noncompliant
+
        
+
        Compliant solution
        
+
        +from assertpy import assert_that
+
+def test_string_conversion():
+    actual = str(42)
+    expected = "42"
+    assert_that(actual).is_equal_to(expected)
+
        
+
        Resources
        
+
        Documentation
        
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5863.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5863.json
new file mode 100644
index 0000000000..c87776075c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5863.json
@@ -0,0 +1,23 @@
+{
+  "title": "Assertions should not be given twice the same argument",
+  "type": "BUG",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  },
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-5863",
+  "sqKey": "S5863",
+  "scope": "Tests",
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5958.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5958.html
new file mode 100644
index 0000000000..f09a4ab79c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5958.html
@@ -0,0 +1,118 @@
+
        This is an issue when test code verifies that an exception was raised without checking its type or its message.
        
+
        Why is this an issue?
        
+
        Assertions are statements that check whether certain conditions are true. They validate that the actual results of a code snippet match the
+expected outcomes. By using assertions, developers ensure their code behaves as intended and identify potential bugs or issues early in the
+development process.
        
+
        When testing exception handling, it is not sufficient to verify only that some exception was raised. Tests should also validate the
+exception type or message to differentiate expected exceptions from unexpected ones.
        
+
        Consider a function that should raise a ValueError when given invalid input. If your test only checks that an exception occurred, it
+cannot distinguish between:
        
+
          
+  
        • The expected ValueError indicating proper input validation
          • 
+  
        • An unexpected TypeError from a bug in the code
          • 
+  
        • An unexpected AttributeError from a null reference error
          • 
+
        
+
        All three scenarios would make the test pass, even though two represent actual bugs.
        
+
        In Python testing frameworks like pytest and unittest, several patterns can lead to insufficiently specific exception testing:
        
+
          
+  
        • Using pytest.raises(Exception) without specifying the exception type or checking the message
          • 
+  
        • Using unittest.assertRaises(Exception) which catches any exception
          • 
+  
        • Not validating the exception message when the same exception type could be raised for different reasons
          • 
+  
        • Catching exceptions in try-except blocks without asserting on the caught exception
          • 
+
        
+
        These patterns create fragile tests that may pass for the wrong reasons, allowing bugs to slip through your test suite undetected.
        
+
        What is the potential impact?
        
+
        Tests that do not verify the exception type or message can:
        
+
          
+  
        • Miss bugs: Your tests may pass even when your code throws unexpected exceptions due to bugs
          • 
+  
        • Reduce confidence: You cannot trust that your error handling works correctly
          • 
+  
        • Hide breaking changes: Refactoring that changes exception types will not be caught by tests
          • 
+  
        • Complicate debugging: When tests fail, you will not have clear information about what went wrong
          • 
+
        
+
        This weakens the safety net that your test suite provides and can lead to production issues that could have been caught during development.
        
+
        How to fix it in pytest
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +import pytest
+
+class InvalidConfigError(Exception):
+    def __init__(self, field, message):
+        self.field = field
+        super().__init__(message)
+
+def load_config(data):
+    if 'api_key' not in data:
+        raise InvalidConfigError('api_key', 'Missing required field')
+
+def test_missing_config():
+    with pytest.raises(Exception):  # Noncompliant: does not verify the type or the message
+        load_config({})
+
        
+
        Compliant solution
        
+
        With pytest, use pytest.raises() with a specific exception type instead of the generic Exception class, or use the
+match parameter to validate the exception message using a regular expression pattern. You can also use both when appropriate.
        
+
        +import pytest
+
+class InvalidConfigError(Exception):
+    def __init__(self, field, message):
+        self.field = field
+        super().__init__(message)
+
+def load_config(data):
+    if 'api_key' not in data:
+        raise InvalidConfigError('api_key', 'Missing required field')
+
+def test_missing_config_type():
+    with pytest.raises(InvalidConfigError) as exc_info:
+        load_config({})
+
+    assert exc_info.value.field == 'api_key'
+    assert 'Missing required field' in str(exc_info.value)
+
+def test_missing_config_match():
+    with pytest.raises(Exception, match="Missing required field"):
+        load_config({})
+
        
+
        How to fix it in unittest
        
+
        With unittest, use assertRaises() with a specific exception type, or assertRaisesRegex() when you want to verify the
+message as well. You can use either approach depending on what the test needs to verify.
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +import unittest
+
+def parse_age(value):
+    age = int(value)
+    if age < 0:
+        raise ValueError("Age cannot be negative")
+    return age
+
+class TestAgeParser(unittest.TestCase):
+    def test_negative_age(self):
+        with self.assertRaises(Exception):  # Noncompliant: does not verify which exception
+            parse_age("-5")
+
        
+
        Compliant solution
        
+
        +import unittest
+
+def parse_age(value):
+    age = int(value)
+    if age < 0:
+        raise ValueError("Age cannot be negative")
+    return age
+
+class TestAgeParser(unittest.TestCase):
+    def test_negative_age(self):
+        with self.assertRaises(ValueError):
+            parse_age("-5")
+
        
+
        Resources
        
+
        Documentation
        
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5958.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5958.json
new file mode 100644
index 0000000000..5cfd122eed
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5958.json
@@ -0,0 +1,23 @@
+{
+  "title": "Tests should check which exception is thrown",
+  "type": "CODE_SMELL",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "TESTED"
+  },
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-5958",
+  "sqKey": "S5958",
+  "scope": "Tests",
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5976.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5976.html
new file mode 100644
index 0000000000..c1a4b1a82e
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5976.html
@@ -0,0 +1,94 @@
+
        This rule raises an issue when at least 3 test methods could be refactored into a single parameterized test with less than 4 parameters.
        
+
        Why is this an issue?
        
+
        When multiple tests differ only by a few hardcoded values, they should be refactored into a single parameterized test. This reduces duplication,
+makes the tests easier to read, and lowers the risk of introducing bugs when the test logic needs to change.
        
+
        Parameterized tests are supported by most testing frameworks.
        
+
        The right balance still needs to be found. There is little value in parameterizing tests when the resulting test becomes significantly more complex
+than the original versions.
        
+
        What is the potential impact?
        
+
        Duplicated test methods lead to higher maintenance costs and increased likelihood of bugs. When test logic needs to be updated, developers must
+remember to make identical changes across multiple methods, which is easy to forget.
        
+
        This can result in inconsistent test coverage where some variations of a test are updated while others remain outdated. Such inconsistencies can
+cause false positives or, worse, false negatives that let bugs slip through.
        
+
        The impact on team productivity compounds over time as the test suite grows. More time is spent maintaining redundant code instead of writing new
+tests or improving application code.
        
+
        How to fix it in pytest
        
+
        Use pytest’s @pytest.mark.parametrize decorator to combine similar tests into a single parameterized test. The decorator accepts a
+string of parameter names and a list of tuples containing the values for each test case.
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +import pytest
+
+class TestApp:
+    def test_level1(self):  # Noncompliant
+        set_level(1)
+        run_game()
+        assert player_health() == 100
+
+    def test_level2(self):
+        set_level(2)
+        run_game()
+        assert player_health() == 200
+
+    def test_level3(self):
+        set_level(3)
+        run_game()
+        assert player_health() == 300
+
        
+
        Compliant solution
        
+
        +import pytest
+
+class TestApp:
+    @pytest.mark.parametrize("level,health", [
+        (1, 100),
+        (2, 200),
+        (3, 300),
+    ])
+    def test_levels(self, level, health):
+        set_level(level)
+        run_game()
+        assert player_health() == health
+
        
+
        How to fix it in unittest
        
+
        For unittest, you can use the parameterized library to achieve similar functionality. Install it with pip install
+parameterized and use the @parameterized.expand decorator.
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +import unittest
+
+class TestApp(unittest.TestCase):
+    def test_not_null1(self):  # Noncompliant
+        setup_tax()
+        self.assertIsNotNone(get_tax(1))
+
+    def test_not_null2(self):
+        setup_tax()
+        self.assertIsNotNone(get_tax(2))
+
+    def test_not_null3(self):
+        setup_tax()
+        self.assertIsNotNone(get_tax(3))
+
        
+
        Compliant solution
        
+
        +import unittest
+from parameterized import parameterized
+
+class TestApp(unittest.TestCase):
+    @parameterized.expand([1, 2, 3])
+    def test_not_null(self, tax_id):
+        setup_tax()
+        self.assertIsNotNone(get_tax(tax_id))
+
        
+
        Resources
        
+
        Documentation
        
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5976.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5976.json
new file mode 100644
index 0000000000..8ac4091d60
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S5976.json
@@ -0,0 +1,25 @@
+{
+  "title": "Similar tests should be grouped in a single Parameterized test",
+  "type": "CODE_SMELL",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CONVENTIONAL"
+  },
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "10min"
+  },
+  "tags": [
+    "tests",
+    "bad-practice",
+    "clumsy"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-5976",
+  "sqKey": "S5976",
+  "scope": "Tests",
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6245.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6245.html
deleted file mode 100644
index e876ca12c6..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6245.html
+++ /dev/null
@@ -1,58 +0,0 @@
-
        This rule is deprecated, and will eventually be removed.
        
-
        Server-side encryption (SSE) encrypts an object (not the metadata) as it is written to disk (where the S3 bucket resides) and decrypts it as it is
-read from disk. This doesn’t change the way the objects are accessed, as long as the user has the necessary permissions, objects are retrieved as if
-they were unencrypted. Thus, SSE only helps in the event of disk thefts, improper disposals of disks and other attacks on the AWS infrastructure
-itself.
        
-
        There are three SSE options:
        
-
          
-  
        • Server-Side Encryption with Amazon S3-Managed Keys (SSE-S3)
-    
            
-      
          • AWS manages encryption keys and the encryption itself (with AES-256) on its own.
            • 
-    
          • 
-  
        • Server-Side Encryption with Customer Master Keys (CMKs) Stored in AWS Key Management Service (SSE-KMS)
-    
            
-      
          • AWS manages the encryption (AES-256) of objects and encryption keys provided by the AWS KMS service.
            • 
-    
          • 
-  
        • Server-Side Encryption with Customer-Provided Keys (SSE-C)
-    
            
-      
          • AWS manages only the encryption (AES-256) of objects with encryption keys provided by the customer. AWS doesn’t store the customer’s
-      encryption keys.
            • 
-    
          • 
-
        
-
        Ask Yourself Whether
        
-
          
-  
        • The S3 bucket stores sensitive information.
          • 
-  
        • The infrastructure needs to comply to some regulations, like HIPAA or PCI DSS, and other standards.
          • 
-
        
-
        There is a risk if you answered yes to any of those questions.
        
-
        Recommended Secure Coding Practices
        
-
        It’s recommended to use SSE. Choosing the appropriate option depends on the level of control required for the management of encryption keys.
        
-
        Sensitive Code Example
        
-
        Server-side encryption is not used:
        
-
        -bucket = s3.Bucket(self,"bucket",
-    encryption=s3.BucketEncryption.UNENCRYPTED       # Sensitive
-)
-
        
-
        The default value of encryption is KMS if encryptionKey is set. Otherwise, if both parameters are absent the
-bucket is unencrypted.
        
-
        Compliant Solution
        
-
        Server-side encryption with Amazon S3-Managed Keys is used:
        
-
        -bucket = s3.Bucket(self,"bucket",
-    encryption=s3.BucketEncryption.S3_MANAGED
-)
-
-# Alternatively with a KMS key managed by the user.
-
-bucket = s3.Bucket(self,"bucket",
-    encryptionKey=access_key
-)
-
        
-
        See
        
-
-
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6245.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6245.json
deleted file mode 100644
index 8da80d623f..0000000000
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6245.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-  "title": "Disabling server-side encryption of S3 buckets is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
-  "code": {
-    "impacts": {
-      "SECURITY": "LOW"
-    },
-    "attribute": "COMPLETE"
-  },
-  "status": "deprecated",
-  "tags": [
-    "deprecated"
-  ],
-  "defaultSeverity": "Minor",
-  "ruleSpecification": "RSPEC-6245",
-  "sqKey": "S6245",
-  "scope": "Main",
-  "securityStandards": {
-    "CWE": [
-      311
-    ],
-    "PCI DSS 3.2": [
-      "6.5.3"
-    ],
-    "PCI DSS 4.0": [
-      "6.2.4"
-    ]
-  }
-}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6249.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6249.html
index 4287627bfd..199850931b 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6249.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6249.html
@@ -1,70 +1,43 @@
-
        By default, S3 buckets can be accessed through HTTP and HTTPs protocols.
        
-
        As HTTP is a clear-text protocol, it lacks the encryption of transported data, as well as the capability to build an authenticated connection. It
-means that a malicious actor who is able to intercept traffic from the network can read, modify or corrupt the transported content.
        
-
        Ask Yourself Whether
        
-
          
-  
        • The S3 bucket stores sensitive information.
          • 
-  
        • The infrastructure has to comply with AWS Foundational Security Best Practices standard.
          • 
-
        
-
        There is a risk if you answered yes to any of those questions.
        
-
        Recommended Secure Coding Practices
        
-
        It’s recommended to deny all HTTP requests:
        
-
          
-  
        • for all objects (*) of the bucket
          • 
-  
        • for all principals (*)
          • 
-  
        • for all actions (*)
          • 
-
        
-
        Sensitive Code Example
        
-
        No secure policy is attached to this bucket:
        
-
        +
        By default, S3 buckets can be accessed through both HTTP and HTTPS protocols.
        
+
        Why is this an issue?
        
+
        HTTP is a cleartext protocol: it provides no encryption for data in transit and does not support authenticated connections. An attacker with the
+ability to intercept network traffic can read, modify, or corrupt data transmitted between a client and an S3 bucket over HTTP. This rule raises an
+issue when an S3 bucket has no policy that explicitly denies HTTP requests for all principals, all actions, and all objects.
        
+
        What is the potential impact?
        
+
        Data interception
        
+
        An attacker positioned on the network path between clients and the S3 bucket can read all data transmitted over HTTP in cleartext, including file
+contents and any credentials present in request headers.
        
+
        Data tampering
        
+
        Without transport encryption, a network attacker can modify requests or responses as they flow between the client and S3, corrupting stored data or
+injecting malicious content without detection.
        
+
        How to fix it
        
+
        Code examples
        
+
        The following code does not enforce HTTPS-only access to the S3 bucket, allowing HTTP requests to succeed.
        
+
        Noncompliant code example
        
+
         import aws_cdk.aws_s3 as s3
-import aws_cdk.aws_iam as iam
 
-bucket = s3.Bucket(self, "bucket") # Sensitive
+bucket = s3.Bucket(self, "bucket") # Noncompliant
 
        
-
        A policy is defined but forces only HTTPs communication for some users, some objects of the bucket and for some actions:
        
-
        -bucket = s3.Bucket(self, "bucket")
-bucket.add_to_resource_policy(iam.PolicyStatement(     # Sensitive
-    effect=iam.Effect.DENY,
-    resources=[bucket.bucket_arn],
-    actions=["s3:SomeAction"],
-    principals=[roles],
-    conditions=[{"Bool": {"aws:SecureTransport": False}}]
-    )
-)
-
        
-
        Compliant Solution
        
-
        A bucket policy that complies with s3-bucket-ssl-requests-only rule should be used. To adhere to it, the bucket policies need to explicitly deny
-access to HTTP requests.
        
-
        A secure policy that enforces SSL on requests (default: False):
        
-
        -bucket = S3.Bucket(self,
+
        Compliant solution
        
+
        +import aws_cdk.aws_s3 as s3
+
+bucket = s3.Bucket(self,
     "bucket",
     enforce_ssl=True
 )
 
        
-
        A secure policy that denies all HTTP requests is used:
        
-
        -bucket = s3.Bucket(self, "bucket")
-
-result = bucket.add_to_resource_policy(iam.PolicyStatement(
-    effect=iam.Effect.DENY,
-    resources=["*"],
-    actions=["s3:*"],
-    principals=["*"],
-    conditions=["SecureTransport:False"]
-    )
-)
-
        
-
        See
        
+
        Resources
        
+
        Documentation
        
 
+
        Standards
        
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6249.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6249.json
index 1b0ea7eee7..8acd2b5686 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6249.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6249.json
@@ -1,22 +1,24 @@
 {
-  "title": "Authorizing HTTP communications with S3 buckets is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "S3 buckets should enforce HTTPS-only access",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
-      "SECURITY": "HIGH"
+      "SECURITY": "LOW"
     },
-    "attribute": "COMPLETE"
+    "attribute": "TRUSTWORTHY"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "10min"
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
-  "defaultSeverity": "Critical",
+  "defaultSeverity": "Minor",
   "ruleSpecification": "RSPEC-6249",
   "sqKey": "S6249",
   "scope": "Main",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6252.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6252.html
index fc65b04dc7..a8ead7ff14 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6252.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6252.html
@@ -1,30 +1,39 @@
-
        S3 buckets can be versioned. When the S3 bucket is unversioned it means that a new version of an object overwrites an existing one in the S3
-bucket.
        
-
        It can lead to unintentional or intentional information loss.
        
-
        Ask Yourself Whether
        
-
          
-  
        • The bucket stores information that require high availability.
          • 
-
        
-
        There is a risk if you answered yes to any of those questions.
        
-
        Recommended Secure Coding Practices
        
-
        It’s recommended to enable S3 versioning and thus to have the possibility to retrieve and restore different versions of an object.
        
-
        Sensitive Code Example
        
-
        +
        Amazon S3 buckets can be unversioned, have versioning enabled, or have versioning suspended.
        
+
        Why is this an issue?
        
+
        When an S3 bucket is unversioned or has versioning suspended, uploading a new object overwrites the previous one instead of preserving prior
+versions. The rule flags buckets without versioning enabled, including when the versioning property is omitted and defaults to disabled.
        
+
        What is the potential impact?
        
+
        Data loss
        
+
        Objects can be permanently overwritten or deleted without the ability to restore previous versions. This can result from accidental changes,
+misconfiguration, or malicious activity.
        
+
        Reduced availability of historical data
        
+
        Buckets that store information requiring long-term preservation become vulnerable to unintentional or intentional information loss when versioning
+is not enabled.
        
+
        How to fix it
        
+
        Code examples
        
+
        Versioning is disabled when the property is omitted or explicitly set to disable versioning, so new object uploads overwrite existing ones.
        
+
        Noncompliant code example
        
+
         bucket = s3.Bucket(self, "bucket",
-    versioned=False       # Sensitive
+    versioned=False       # Noncompliant
 )
 
        
-
        The default value of versioned is False so the absence of this parameter is also sensitive.
        
-
        Compliant Solution
        
-
        +
        The default value of versioned is False so the absence of this parameter is also noncompliant.
        
+
        Compliant solution
        
+
         bucket = s3.Bucket(self, "bucket",
     versioned=True
 )
 
        
-
        See
        
+
        Resources
        
+
        Documentation
        
 
+
        Standards
        
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6252.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6252.json
index c0d4ca7e87..7bd717dee1 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6252.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6252.json
@@ -1,6 +1,6 @@
 {
-  "title": "Disabling versioning of S3 buckets is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Amazon S3 buckets should have versioning enabled",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "LOW"
@@ -8,12 +8,14 @@
     "attribute": "CONVENTIONAL"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "5min"
   },
   "tags": [
-    "aws"
+    "aws",
+    "former-hotspot"
   ],
   "defaultSeverity": "Minor",
   "ruleSpecification": "RSPEC-6252",
@@ -27,8 +29,7 @@
       "10.2.1.7"
     ],
     "CWE": [
-      16,
-      693
+      16
     ]
   }
 }
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6265.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6265.html
index 9598a91845..06c6ba103d 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6265.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6265.html
@@ -1,52 +1,63 @@
 
        Predefined permissions, also known as canned ACLs,
-are an easy way to grant large privileges to predefined groups or users.
        
+are an easy way to grant broad privileges to predefined groups or users.
        
 
        The following canned ACLs are security-sensitive:
        
 
          
-  
        • PUBLIC_READ, PUBLIC_READ_WRITE grant respectively "read" and "read and write" privileges to everyone in the world
+  
        • PublicRead, PublicReadWrite grant respectively "read" and "read and write" privileges to everyone in the world
   (AllUsers group).
          • 
-  
        • AUTHENTICATED_READ grants "read" privilege to all authenticated users (AuthenticatedUsers group).
          • 
+  
        • AuthenticatedRead grants "read" privilege to all authenticated users (AuthenticatedUsers group).
          • 
 
        
-
        Ask Yourself Whether
        
-
          
-  
        • The S3 bucket stores sensitive data.
          • 
-  
        • The S3 bucket is not used to store static resources of websites (images, css …​).
          • 
-
        
-
        There is a risk if you answered yes to any of those questions.
        
-
        Recommended Secure Coding Practices
        
-
        It’s recommended to implement the least privilege policy, i.e., to grant necessary permissions only to users for their required tasks. In the
-context of canned ACL, set it to PRIVATE (the default one), and if needed more granularity then use an appropriate S3 policy.
        
-
        Sensitive Code Example
        
-
        All users (ie: anyone in the world authenticated or not) have read and write permissions with the PUBLIC_READ_WRITE access
-control:
        
-
        +
        Why is this an issue?
        
+
        When an S3 bucket is configured with a canned ACL such as PublicRead, PublicReadWrite, or AuthenticatedRead,
+it grants broad read or write access to either all internet users or all authenticated AWS users, far beyond what is typically required.
        
+
        What is the potential impact?
        
+
        Unauthorized data access
        
+
        When an S3 bucket is publicly readable, any user on the internet can enumerate and download its contents. This can expose sensitive business data,
+personally identifiable information (PII), credentials, or configuration files to unauthorized parties.
        
+
        Data tampering
        
+
        When an S3 bucket is publicly writable (e.g., PublicReadWrite), attackers can upload malicious files, overwrite existing objects, or
+delete bucket content, leading to data integrity loss or supply chain attacks if the bucket serves application assets.
        
+
        How to fix it in AWS CDK
        
+
        Set the access_control property to PRIVATE (the default) to restrict bucket access to the owner only. For more granular
+access control, use an appropriate S3 bucket policy instead of canned ACLs.
        
+
        Code examples
        
+
        Noncompliant code example
        
+
        +import aws_cdk.aws_s3 as s3
+import aws_cdk.aws_s3_deployment as s3deploy
+
 bucket = s3.Bucket(self, "bucket",
-    access_control=s3.BucketAccessControl.PUBLIC_READ_WRITE     # Sensitive
+    access_control=s3.BucketAccessControl.PUBLIC_READ_WRITE     # Noncompliant
 )
 
 s3deploy.BucketDeployment(self, "DeployWebsite",
-    access_control=s3.BucketAccessControl.PUBLIC_READ_WRITE     # Sensitive
+    access_control=s3.BucketAccessControl.PUBLIC_READ_WRITE     # Noncompliant
 )
 
        
-
        Compliant Solution
        
-
        With the PRIVATE access control (default), only the bucket owner has the read/write permissions on the buckets and its ACL.
        
-
        +
        Compliant solution
        
+
        +import aws_cdk.aws_s3 as s3
+import aws_cdk.aws_s3_deployment as s3deploy
+
 bucket = s3.Bucket(self, "bucket",
-    access_control=s3.BucketAccessControl.PRIVATE       # Compliant
+    access_control=s3.BucketAccessControl.PRIVATE
 )
 
-# Another example
 s3deploy.BucketDeployment(self, "DeployWebsite",
-    access_control=s3.BucketAccessControl.PRIVATE       # Compliant
+    access_control=s3.BucketAccessControl.PRIVATE
 )
 
        
-
        See
        
+
        Resources
        
+
        Documentation
        
 
+
        Standards
        
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6265.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6265.json
index 8dc2b8d2c6..46e0baa37f 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6265.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6265.json
@@ -1,6 +1,6 @@
 {
-  "title": "Granting access to S3 buckets to all or authenticated users is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "S3 buckets should not grant access to all users or authenticated users",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "BLOCKER"
@@ -8,13 +8,15 @@
     "attribute": "CONVENTIONAL"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "5min"
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-6265",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6270.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6270.html
index 612078b157..213a6ff3d8 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6270.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6270.html
@@ -1,16 +1,17 @@
 
        Resource-based policies granting access to all users can lead to information leakage.
        
-
        Ask Yourself Whether
        
-
          
-  
        • The AWS resource stores or processes sensitive data.
          • 
-  
        • The AWS resource is designed to be private.
          • 
-
        
-
        There is a risk if you answered yes to any of those questions.
        
-
        Recommended Secure Coding Practices
        
-
        It’s recommended to implement the least privilege principle, i.e. to grant necessary permissions only to users for their required tasks. In the
-context of resource-based policies, list the principals that need the access and grant to them only the required privileges.
        
-
        Sensitive Code Example
        
-
        This policy allows all users, including anonymous ones, to access an S3 bucket:
        
-
        +
        Why is this an issue?
        
+
        Resource-based policies in AWS define who can access a resource and what actions they can perform. When the Principal element of a
+policy is set to "*", access is granted to all users, including anonymous and unauthenticated ones. This violates the principle of least
+privilege and can expose sensitive data or operations to unauthorized parties.
        
+
        What is the potential impact?
        
+
        Unauthorized data access
        
+
        When a resource-based policy grants access to all principals, any user on the internet can read, modify, or delete the resource’s contents. This
+can lead to data breaches, exposure of sensitive information, and potential misuse of cloud resources.
        
+
        How to fix it in AWS CDK
        
+
        Use a specific principal such as AccountRootPrincipal instead of AnyPrincipal.
        
+
        Code examples
        
+
        Noncompliant code example
        
+
         from aws_cdk.aws_iam import PolicyStatement, AnyPrincipal, Effect
 from aws_cdk.aws_s3 import Bucket
 
@@ -20,12 +21,11 @@ 
        Sensitive Code Example
        
   effect=Effect.ALLOW,
   actions=["s3:*"],
   resources=[bucket.arn_for_objects("*")],
-  principals=[AnyPrincipal()] # Sensitive
+  principals=[AnyPrincipal()] # Noncompliant
 ))
 
        
-
        Compliant Solution
        
-
        This policy allows only the authorized users:
        
-
        +
        Compliant solution
        
+
         from aws_cdk.aws_iam import PolicyStatement, AccountRootPrincipal, Effect
 from aws_cdk.aws_s3 import Bucket
 
@@ -38,10 +38,14 @@ 
        Compliant Solution
        
   principals=[AccountRootPrincipal()]
 ))
 
        
-
        See
        
+
        Resources
        
+
        Documentation
        
 
+
        Standards
        
+
          
   
        • CWE - CWE-732 - Incorrect Permission Assignment for Critical Resource
          • 
   
        • CWE - CWE-284 - Improper Access Control
          • 
   
        • STIG Viewer - Application Security and
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6270.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6270.json
index 1e245b985b..2870a61c4e 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6270.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6270.json
@@ -1,6 +1,6 @@
 {
-  "title": "Policies authorizing public access to resources are security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "AWS resource-based policies should not grant public access",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "BLOCKER"
@@ -8,13 +8,15 @@
     "attribute": "CONVENTIONAL"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "5min"
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-6270",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6275.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6275.html
index 4f658aac2d..1857084d77 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6275.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6275.html
@@ -1,22 +1,19 @@
-
          Amazon Elastic Block Store (EBS) is a block-storage service for Amazon Elastic Compute Cloud (EC2). EBS volumes can be encrypted, ensuring the
-security of both data-at-rest and data-in-transit between an instance and its attached EBS storage. In the case that adversaries gain physical access
-to the storage medium they are not able to access the data. Encryption can be enabled for specific volumes or for all new volumes and snapshots. Volumes created
-from snapshots inherit their encryption configuration. A volume created from an encrypted snapshot will also be encrypted by default.
          
-
          Ask Yourself Whether
          
-
            
-  
          • The disk contains sensitive data that could cause harm when leaked.
            • 
-  
          • There are compliance requirements for the service to store data encrypted.
            • 
-
          
-
          There is a risk if you answered yes to any of those questions.
          
-
          Recommended Secure Coding Practices
          
-
          It’s recommended to encrypt EBS volumes that contain sensitive information. Encryption and decryption are handled transparently by EC2, so no
-further modifications to the application are necessary. Instead of enabling encryption for every volume, it is also possible to enable encryption
-globally for a specific region. While creating volumes from encrypted snapshots will result in them being encrypted, explicitly enabling this security
-parameter will prevent any future unexpected security downgrade.
          
-
          Sensitive Code Example
          
-
          For aws_cdk.aws_ec2.Volume:
          
-
          +
          Amazon Elastic Block Store (EBS) is a block-storage service for Amazon EC2 that supports encryption of data at rest and in transit.
          
+
          Why is this an issue?
          
+
          When EBS volume encryption is disabled, data stored on the volume is not protected cryptographically. If an attacker gains access to the underlying
+storage — for example, through a misconfigured snapshot or a compromised AWS account — the data is exposed in plaintext. Encryption and decryption are
+handled transparently by EC2, so enabling it requires no modifications to the application.
          
+
          What is the potential impact?
          
+
          Exposure of sensitive data
          
+
          Unencrypted EBS volumes can expose all data they contain if the underlying storage is accessed without authorization. This includes database files,
+application data, logs, and other sensitive information that an attacker could read, copy, or exfiltrate, leading to data breaches and regulatory
+non-compliance.
          
+
          How to fix it
          
+
          Code examples
          
+
          EBS volume encryption is disabled, either explicitly by setting the encryption attribute to false or implicitly by omitting it when
+the default encryption setting is not enabled.
          
+
          Noncompliant code example
          
+
           from aws_cdk.aws_ec2 import Volume
 
 class EBSVolumeStack(Stack):
@@ -24,28 +21,13 @@ 
          Sensitive Code Example
          
     def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
         super().__init__(scope, construct_id, **kwargs)
         Volume(self,
-            "unencrypted-explicit",
-            availability_zone="eu-west-1a",
-            size=Size.gibibytes(1),
-            encrypted=False  # Sensitive
-        )
-
          
-
          -from aws_cdk.aws_ec2 import Volume
-
-class EBSVolumeStack(Stack):
-
-    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
-        super().__init__(scope, construct_id, **kwargs)
-        Volume(self,
-            "unencrypted-implicit",
+            "example-volume",
             availability_zone="eu-west-1a",
             size=Size.gibibytes(1)
-        ) # Sensitive as encryption is disabled by default
+        ) # Noncompliant: encryption is disabled by default
 
          
-
          Compliant Solution
          
-
          For aws_cdk.aws_ec2.Volume:
          
-
          +
          Compliant solution
          
+
           from aws_cdk.aws_ec2 import Volume
 
 class EBSVolumeStack(Stack):
@@ -53,15 +35,20 @@ 
          Compliant Solution
          
     def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
         super().__init__(scope, construct_id, **kwargs)
         Volume(self,
-            "encrypted-explicit",
+            "example-volume",
             availability_zone="eu-west-1a",
             size=Size.gibibytes(1),
             encrypted=True
         )
 
          
-
          See
          
+
          Resources
          
+
          Documentation
          
 
+
          Standards
          
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6275.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6275.json
index 08beb104e0..bf39e09e3b 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6275.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6275.json
@@ -1,6 +1,6 @@
 {
-  "title": "Using unencrypted EBS volumes is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "EBS volumes should be encrypted",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
@@ -8,9 +8,15 @@
     "attribute": "TRUSTWORTHY"
   },
   "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "30min"
+  },
+  "quickfix": "unknown",
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-6275",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6281.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6281.html
index 225a923561..c6c5f4d796 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6281.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6281.html
@@ -1,85 +1,79 @@
-
          By default S3 buckets are private, it means that only the bucket owner can access it.
          
-
          This access control can be relaxed with ACLs or policies.
          
-
          To prevent permissive policies to be set on a S3 bucket the following booleans settings can be enabled:
          
-
            
-  
          • block_public_acls: to block or not public ACLs to be set to the S3 bucket.
            • 
-  
          • ignore_public_acls: to consider or not existing public ACLs set to the S3 bucket.
            • 
-  
          • block_public_policy: to block or not public policies to be set to the S3 bucket.
            • 
-  
          • restrict_public_buckets: to restrict or not the access to the S3 endpoints of public policies to the principals within the bucket
-  owner account.
            • 
-
          
-
          The other attribute BlockPublicAccess.BLOCK_ACLS only turns on block_public_acls and ignore_public_acls. The
-public policies can still affect the S3 bucket.
          
-
          However, all of those options can be enabled by setting the block_public_access property of the S3 bucket to
-BlockPublicAccess.BLOCK_ALL.
          
-
          Ask Yourself Whether
          
-
            
-  
          • The S3 bucket stores sensitive data.
            • 
-  
          • The S3 bucket is not used to store static resources of websites (images, css …​).
            • 
-  
          • Many users have the permission to set ACL or policy to the S3 bucket.
            • 
-  
          • These settings are not already enforced to true at the account level.
            • 
-
          
-
          There is a risk if you answered yes to any of those questions.
          
-
          Recommended Secure Coding Practices
          
-
          It’s recommended to configure:
          
-
            
-  
          • block_public_acls to True to block new attempts to set public ACLs.
            • 
-  
          • ignore_public_acls to True to block existing public ACLs.
            • 
-  
          • block_public_policy to True to block new attempts to set public policies.
            • 
-  
          • restrict_public_buckets to True to restrict existing public policies.
            • 
-
          
-
          Sensitive Code Example
          
-
          By default, when not set, the block_public_access is fully deactivated (nothing is blocked):
          
-
          +
          Amazon S3 provides four independent Public Access Block settings to prevent public access from being granted to a bucket through ACLs or bucket
+policies. This rule flags S3 bucket configurations where any of these settings is set to false.
          
+
          Why is this an issue?
          
+
          Amazon S3 buckets are private by default, but their access control can be relaxed using ACLs or bucket policies that allow public access. Although
+AWS enables all four Public Access Block settings by default, infrastructure code can inadvertently re-expose a bucket by setting any of them to
+false.
          
+
          What is the potential impact?
          
+
          If public access is not fully blocked on an S3 bucket that contains sensitive data, any unauthenticated user on the internet can read, download, or
+exfiltrate that data. This can lead to data breaches, compliance violations, and reputational damage to the organization.
          
+
          How to fix it
          
+
          Code examples
          
+
          Noncompliant code example
          
+
           bucket = s3.Bucket(self,
-    "bucket"        # Sensitive
+    "bucket",
+    block_public_access=s3.BlockPublicAccess(
+        block_public_acls=False,       # Noncompliant
+        ignore_public_acls=True,
+        block_public_policy=True,
+        restrict_public_buckets=True
+    )
 )
 
          
-
          This block_public_access allows public ACL to be set:
          
-
          +
          Compliant solution
          
+
           bucket = s3.Bucket(self,
     "bucket",
     block_public_access=s3.BlockPublicAccess(
-        block_public_acls=False,       # Sensitive
+        block_public_acls=True,
         ignore_public_acls=True,
         block_public_policy=True,
         restrict_public_buckets=True
     )
 )
 
          
-
          The attribute BLOCK_ACLS only blocks and ignores public ACLs:
          
-
          +
          The attribute BLOCK_ACLS_ONLY only blocks and ignores public ACLs, but public policies can still affect the S3 bucket:
          
+
          Noncompliant code example
          
+
           bucket = s3.Bucket(self,
     "bucket",
-    block_public_access=s3.BlockPublicAccess.BLOCK_ACLS     # Sensitive
+    block_public_access=s3.BlockPublicAccess.BLOCK_ACLS_ONLY     # Noncompliant
 )
 
          
-
          Compliant Solution
          
-
          This block_public_access blocks public ACLs and policies, ignores existing public ACLs and restricts existing public policies:
          
-
          +
          Compliant solution
          
+
           bucket = s3.Bucket(self,
     "bucket",
-    block_public_access=s3.BlockPublicAccess.BLOCK_ALL # Compliant
+    block_public_access=s3.BlockPublicAccess.BLOCK_ALL
 )
 
          
-
          A similar configuration to the one above can obtained by setting all parameters of the block_public_access
          
-
          -bucket = s3.Bucket(self, "bucket",
-    block_public_access=s3.BlockPublicAccess(       # Compliant
-        block_public_acls=True,
-        ignore_public_acls=True,
-        block_public_policy=True,
-        restrict_public_buckets=True
-    )
-)
-
          
-
          See
          
+
          How does this work?
          
+
          The BlockPublicAccess class controls public access to an S3 bucket through four independent settings:
          
+
            
+  
          • block_public_acls: blocks new public ACLs from being set on the bucket.
            • 
+  
          • ignore_public_acls: causes existing public ACLs on the bucket to be ignored.
            • 
+  
          • block_public_policy: blocks new public bucket policies from being set.
            • 
+  
          • restrict_public_buckets: restricts access to the bucket to principals within the bucket owner account when a public policy is in
+  effect.
            • 
+
          
+
          When block_public_access is not set, or when BlockPublicAccess(…​) is used with some attributes omitted, AWS CDK defaults
+the missing attributes to True. The BlockPublicAccess.BLOCK_ALL preset enables all four settings explicitly, providing
+complete protection. The BlockPublicAccess.BLOCK_ACLS_ONLY preset only enables block_public_acls and
+ignore_public_acls, explicitly setting block_public_policy and restrict_public_buckets to
+False.
          
+
          Resources
          
+
          Documentation
          
 
+
          Standards
          
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6281.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6281.json
index df73b72899..4a5eb2a8ff 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6281.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6281.json
@@ -1,6 +1,6 @@
 {
-  "title": "Allowing public ACLs or policies on a S3 bucket is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Amazon S3 bucket public access should be fully blocked",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "HIGH"
@@ -8,13 +8,15 @@
     "attribute": "COMPLETE"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
-    "constantCost": "5min"
+    "constantCost": "30min"
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Critical",
   "ruleSpecification": "RSPEC-6281",
@@ -22,7 +24,8 @@
   "scope": "Main",
   "securityStandards": {
     "CWE": [
-      284
+      284,
+      732
     ],
     "PCI DSS 3.2": [
       "6.5.8"
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6302.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6302.html
index 8db9ac3381..8b8370b8d1 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6302.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6302.html
@@ -1,32 +1,30 @@
-
          A policy that grants all permissions may indicate an improper access control, which violates the principle of least privilege. Suppose an identity is granted full
-permissions to a resource even though it only requires read permission to work as expected. In this case, an unintentional overwriting of resources
-may occur and therefore result in loss of information.
          
-
          Ask Yourself Whether
          
-
          Identities obtaining all the permissions:
          
-
            
-  
          • only require a subset of these permissions to perform the intended function.
            • 
-  
          • have monitored activity showing that only a subset of these permissions is actually used.
            • 
-
          
-
          There is a risk if you answered yes to any of those questions.
          
-
          Recommended Secure Coding Practices
          
-
          It’s recommended to apply the least privilege principle, i.e. by only granting the necessary permissions to identities. A good practice is to start
-with the very minimum set of permissions and to refine the policy over time. In order to fix overly permissive policies already deployed in
-production, a strategy could be to review the monitored activity in order to reduce the set of permissions to those most used.
          
-
          Sensitive Code Example
          
-
          A customer-managed policy that grants all permissions by using the wildcard (*) in the Action property:
          
-
          +
          Policies that grant all permissions violate the principle of least privilege.
          
+
          Why is this an issue?
          
+
          Policies that grant all permissions — for example by using a wildcard (*) in the action field or by assigning an overly permissive
+role such as roles/owner — give an identity unrestricted access to all operations on a resource. Following the principle of least
+privilege, policies should grant only the minimum set of permissions required for the identity to perform its intended function. Overly permissive
+policies increase the risk of unintentional data modification, data exposure, or full cloud environment compromise if an identity is misused or
+stolen.
          
+
          What is the potential impact?
          
+
          Privilege escalation and data exposure
          
+
          An attacker who gains control of an identity with full permissions can perform any operation on any resource, including reading, modifying, or
+deleting sensitive data. They can also escalate privileges by creating new identities or modifying other policies, potentially leading to a full
+compromise of the cloud environment.
          
+
          How to fix it
          
+
          Code examples
          
+
          The following code grants full permissions to identities instead of limiting them to only those required.
          
+
          Noncompliant code example
          
+
           from aws_cdk.aws_iam import PolicyStatement, Effect
 
 PolicyStatement(
     effect=Effect.ALLOW,
-    actions=["*"], # Sensitive
+    actions=["*"], # Noncompliant
     resources=["arn:aws:iam:::user/*"]
 )
 
          
-
          Compliant Solution
          
-
          A customer-managed policy that grants only the required permissions:
          
-
          +
          Compliant solution
          
+
           from aws_cdk.aws_iam import PolicyStatement, Effect
 
 PolicyStatement(
@@ -35,11 +33,15 @@ 
          Compliant Solution
          
     resources=["arn:aws:iam:::user/*"]
 )
 
          
-
          See
          
+
          Resources
          
+
          Documentation
          
 
+
          Standards
          
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6302.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6302.json
index 1b7b778c75..c99f499320 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6302.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6302.json
@@ -1,6 +1,6 @@
 {
-  "title": "Policies granting all privileges are security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Policies should not grant all privileges",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "BLOCKER"
@@ -8,13 +8,16 @@
     "attribute": "CONVENTIONAL"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "5min"
   },
   "tags": [
     "cwe",
-    "aws"
+    "aws",
+    "gcp",
+    "former-hotspot"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-6302",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6303.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6303.html
index 7c9c6cccbc..7c5b839f10 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6303.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6303.html
@@ -1,32 +1,26 @@
-
          Using unencrypted RDS DB resources exposes data to unauthorized access.
-  
          
-  This includes database data, logs, automatic backups, read replicas, snapshots, and cluster metadata.
          
-
          This situation can occur in a variety of scenarios, such as:
          
-
            
-  
          • A malicious insider working at the cloud provider gains physical access to the storage device.
            • 
-  
          • Unknown attackers penetrate the cloud provider’s logical infrastructure and systems.
            • 
-
          
-
          After a successful intrusion, the underlying applications are exposed to:
          
-
            
-  
          • theft of intellectual property and/or personal data
            • 
-  
          • extortion
            • 
-  
          • denial of services and security bypasses via data corruption or deletion
            • 
-
          
-
          AWS-managed encryption at rest reduces this risk with a simple switch.
          
-
          Ask Yourself Whether
          
-
            
-  
          • The database contains sensitive data that could cause harm when leaked.
            • 
-  
          • There are compliance requirements for the service to store data encrypted.
            • 
-
          
-
          There is a risk if you answered yes to any of those questions.
          
-
          Recommended Secure Coding Practices
          
-
          It is recommended to enable encryption at rest on any RDS DB resource, regardless of the engine.
-  
          
-  In any case, no further maintenance is required as encryption at rest is fully managed by AWS.
          
-
          Sensitive Code Example
          
+
          AWS Relational Database Service (RDS) supports encryption at rest using AWS Key Management Service (KMS) to protect database instances and
+clusters.
          
+
          Why is this an issue?
          
+
          When RDS database instances and clusters are not encrypted at rest, all data stored on disk is exposed to anyone who gains access to the underlying
+storage. This includes database data, logs, automatic backups, read replicas, snapshots, and cluster metadata. The rule flags explicit disabling of
+storage encryption as well as configurations where the property is omitted and encryption is disabled by default. AWS-managed encryption at rest
+reduces this risk with a simple configuration change and requires no further maintenance.
          
+
          What is the potential impact?
          
+
          Unauthorized Data Access
          
+
          If an attacker or malicious insider gains access to unencrypted RDS storage — whether through a breach of the cloud provider’s infrastructure or
+physical access to storage devices — all stored data is readable in plaintext. This exposes sensitive information such as personal data, financial
+records, or proprietary business data.
          
+
          Data Theft and Compliance Violations
          
+
          Theft of unencrypted data can result in regulatory fines, reputational damage, and legal liability, particularly for data subject to compliance
+requirements such as PCI DSS.
          
+
          How to fix it in AWS CDK
          
+
          Code examples
          
+
          The following examples create RDS resources with storageEncrypted set to false or omitted, which leaves all database
+data, logs, automatic backups, read replicas, and snapshots unprotected at rest.
          
+
          Noncompliant code example
          
 
          For aws_cdk.aws_rds.DatabaseCluster and aws_cdk.aws_rds.DatabaseInstance:
          
-
          +
           from aws_cdk import (
     aws_rds as rds
 )
@@ -34,30 +28,15 @@ 
          Sensitive Code Example
          
 class DatabaseStack(Stack):
     def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
         super().__init__(scope, construct_id, **kwargs)
-        rds.DatabaseCluster( # Sensitive, unencrypted by default
+        rds.DatabaseCluster( # Noncompliant, unencrypted by default
             self,
             "example"
         )
 
          
-
          For aws_cdk.aws_rds.CfnDBCluster and aws_cdk.aws_rds.CfnDBInstance:
          
-
          -from aws_cdk import (
-    aws_rds as rds
-)
-
-class DatabaseStack(Stack):
-    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
-        super().__init__(scope, construct_id, **kwargs)
-        rds.CfnDBCluster( # Sensitive, unencrypted by default
-            self,
-            "example"
-        )
-
          
-
          Compliant Solution
          
+
          Compliant solution
          
 
          For aws_cdk.aws_rds.DatabaseCluster and aws_cdk.aws_rds.DatabaseInstance:
          
-
          +
           from aws_cdk import (
     aws_rds as rds
 )
@@ -71,26 +50,14 @@ 
          Compliant Solution
          
             storage_encrypted=True
         )
 
          
-
          For aws_cdk.aws_rds.CfnDBCluster and aws_cdk.aws_rds.CfnDBInstance:
          
-
          -from aws_cdk import (
-    aws_rds as rds
-)
-
-class DatabaseStack(Stack):
-    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
-        super().__init__(scope, construct_id, **kwargs)
-        rds.CfnDBCluster(
-            self,
-            "example",
-            storage_encrypted=True
-        )
-
          
-
          See
          
+
          Resources
          
+
          Documentation
          
 
+
          Standards
          
+
            
   
          • CWE - CWE-311 - Missing Encryption of Sensitive Data
            • 
   
          • STIG Viewer - Application Security and
   Development: V-222588 - The application must implement approved cryptographic mechanisms to prevent unauthorized modification of information at
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6303.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6303.json
index 9ab08ea929..b87b14e7e8 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6303.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6303.json
@@ -1,6 +1,6 @@
 {
-  "title": "Using unencrypted RDS DB resources is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Amazon RDS resources should be encrypted at rest",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
@@ -8,13 +8,15 @@
     "attribute": "TRUSTWORTHY"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "10min"
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-6303",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6304.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6304.html
index ed6aa3f20b..fbae713af3 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6304.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6304.html
@@ -1,19 +1,20 @@
-
            A policy that allows identities to access all resources in an AWS account may violate the principle of least privilege. Suppose an identity has permission to access
-all resources even though it only requires access to some non-sensitive ones. In this case, unauthorized access and disclosure of sensitive
-information will occur.
            
-
            Ask Yourself Whether
            
-
            The AWS account has more than one resource with different levels of sensitivity.
            
-
            A risk exists if you answered yes to this question.
            
-
            Recommended Secure Coding Practices
            
-
            It’s recommended to apply the least privilege principle, i.e., by only granting access to necessary resources. A good practice to achieve this is
-to organize or tag
-resources depending on the sensitivity level of data they store or process. Therefore, managing a secure access control is less prone to errors.
            
-
            Sensitive Code Example
            
-
            The wildcard "*" is specified as the resource for this PolicyStatement. This grants the update permission for all
-policies of the account:
            
-
            +
            IAM policies scope permissions to AWS resources using the Resource element in each policy statement.
            
+
            Why is this an issue?
            
+
            When an IAM policy uses "*" in the Resource element, the granted identity can access every resource in the AWS account,
+even when only a subset is needed. This violates the principle of least privilege.
            
+
            What is the potential impact?
            
+
            Unauthorized access to sensitive resources
            
+
            An identity with overly broad permissions can read, modify, or delete resources it was never intended to access. If the account contains resources
+with different sensitivity levels, a compromised or misused credential exposes all of them.
            
+
            Data disclosure and privilege escalation
            
+
            Attackers who obtain credentials with wildcard resource access can exfiltrate sensitive data or escalate privileges by modifying IAM policies,
+roles, or other security controls across the account.
            
+
            How to fix it
            
+
            Code examples
            
+
            Update permission is granted for all policies when the wildcard (*) is used in the Resource property instead of
+restricting access to a specific subset of resources.
            
+
            Noncompliant code example
            
+
             from aws_cdk.aws_iam import Effect, PolicyDocument, PolicyStatement
 
 PolicyDocument(
@@ -21,14 +22,14 @@ 
            Sensitive Code Example
            
         PolicyStatement(
             effect=Effect.ALLOW,
             actions="iam:CreatePolicyVersion",
-            resources=["*"] # Sensitive
+            resources=["*"] # Noncompliant
         )
     ]
 )
 
            
-
            Compliant Solution
            
+
            Compliant solution
            
 
            Restrict the update permission to the appropriate subset of policies:
            
-
            +
             from aws_cdk import Aws
 from aws_cdk.aws_iam import Effect, PolicyDocument, PolicyStatement
 
@@ -42,15 +43,14 @@ 
            Compliant Solution
            
     ]
 )
 
            
-
            Exceptions
            
-
              
-  
            • Should not be raised on key policies (when AWS KMS actions are used.)
              • 
-  
            • Should not be raised on policies not using any resources (if and only if all actions in the policy never require resources.)
              • 
-
            
-
            See
            
+
            Resources
            
+
            Documentation
            
 
+
            Standards
            
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6304.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6304.json
index 98da3bc2e2..2bf81c9b7a 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6304.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6304.json
@@ -1,6 +1,6 @@
 {
-  "title": "Policies granting access to all resources of an account are security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "IAM policies should not grant access to all account resources",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "BLOCKER"
@@ -8,13 +8,15 @@
     "attribute": "CONVENTIONAL"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "5min"
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-6304",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6308.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6308.html
index 62b25c7dc5..3cb423545a 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6308.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6308.html
@@ -9,74 +9,56 @@
   
          • automated snapshots
            • 
 
          
 
          Thus, adversaries cannot access the data if they gain physical access to the storage medium.
          
-
          Ask Yourself Whether
          
-
            
-  
          • The database contains sensitive data that could cause harm when leaked.
            • 
-  
          • There are compliance requirements for the service to store data encrypted.
            • 
-
          
-
          There is a risk if you answered yes to any of those questions.
          
-
          Recommended Secure Coding Practices
          
-
          It is recommended to encrypt OpenSearch domains that contain sensitive information.
          
-
          OpenSearch handles encryption and decryption transparently, so no further modifications to the application are necessary.
          
-
          Sensitive Code Example
          
-
          For aws_cdk.aws_opensearchservice.Domain:
          
-
          +
          Why is this an issue?
          
+
          OpenSearch domains store indexed data that may contain sensitive information. Without encryption at rest, this data is stored in plain text and can
+be accessed by anyone with physical or administrative access to the underlying storage. This rule detects OpenSearch domain configurations where
+encryption at rest is disabled or not explicitly enabled.
          
+
          What is the potential impact?
          
+
          Disabling encryption at rest leaves stored data vulnerable if the storage medium is compromised.
          
+
          Unauthorized access to sensitive data
          
+
          An attacker who gains physical access to the storage medium, or unauthorized administrative access, can read all indexed data in plain text. This
+may include sensitive business data, personal information, or credentials that can be exploited for further attacks or cause regulatory compliance
+failures.
          
+
          How to fix it
          
+
          Enable encryption at rest by setting encryption_at_rest with enabled=True.
          
+
          Code examples
          
+
          Noncompliant code example
          
+
           from aws_cdk.aws_opensearchservice import Domain, EngineVersion
 
 class DomainStack(Stack):
     def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
         super().__init__(scope, construct_id, **kwargs)
 
-        Domain(self, "Sensitive",
+        Domain(self, "ExampleDomain",
             version=EngineVersion.OPENSEARCH_1_3
-        ) # Sensitive, encryption is disabled by default
+        ) # Noncompliant: encryption is disabled by default
 
          
-
          For aws_cdk.aws_opensearchservice.CfnDomain:
          
-
          -from aws_cdk.aws_opensearchservice import CfnDomain
-
-class CfnDomainStack(Stack):
-    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
-        super().__init__(scope, construct_id, **kwargs)
-
-        CfnDomain(self, "Sensitive") # Sensitive, encryption is disabled by default
-
          
-
          Compliant Solution
          
-
          For aws_cdk.aws_opensearchservice.Domain:
          
-
          +
          Compliant solution
          
+
           from aws_cdk.aws_opensearchservice import Domain, EncryptionAtRestOptions, EngineVersion
 
 class DomainStack(Stack):
     def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
         super().__init__(scope, construct_id, **kwargs)
 
-        Domain(self, "Compliant",
+        Domain(self, "ExampleDomain",
             version=EngineVersion.OPENSEARCH_1_3,
             encryption_at_rest=EncryptionAtRestOptions(
                 enabled=True
             )
         )
 
          
-
          For aws_cdk.aws_opensearchservice.CfnDomain:
          
-
          -from aws_cdk.aws_opensearchservice import CfnDomain
-
-class CfnDomainStack(Stack):
-    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
-        super().__init__(scope, construct_id, **kwargs)
-
-        CfnDomain(self, "Compliant",
-            encryption_at_rest_options=CfnDomain.EncryptionAtRestOptionsProperty(
-                enabled=True
-            )
-        )
-
          
-
          See
          
+
          Resources
          
+
          Documentation
          
 
+
          Standards
          
+
            
   
          • CWE - CWE-311 - Missing Encryption of Sensitive Data
            • 
   
          • STIG Viewer - Application Security and
   Development: V-222588 - The application must implement approved cryptographic mechanisms to prevent unauthorized modification of information at
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6308.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6308.json
index 9c1ce8692f..1049bf62b8 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6308.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6308.json
@@ -1,6 +1,6 @@
 {
-  "title": "Using unencrypted OpenSearch domains is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "OpenSearch domains should have encryption at rest enabled",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
@@ -14,9 +14,11 @@
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
+  "quickfix": "unknown",
   "ruleSpecification": "RSPEC-6308",
   "sqKey": "S6308",
   "scope": "All",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6319.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6319.html
index 23d7b883e3..3a1a6fc38d 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6319.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6319.html
@@ -1,19 +1,19 @@
-
            Amazon SageMaker is a managed machine learning service in a hosted production-ready environment. To train machine learning models, SageMaker
-instances can process potentially sensitive data, such as personal information that should not be stored unencrypted. In the event that adversaries
-physically access the storage media, they cannot decrypt encrypted data.
            
-
            Ask Yourself Whether
            
-
              
-  
            • The instance contains sensitive data that could cause harm when leaked.
              • 
-  
            • There are compliance requirements for the service to store data encrypted.
              • 
-
            
-
            There is a risk if you answered yes to any of those questions.
            
-
            Recommended Secure Coding Practices
            
-
            It’s recommended to encrypt SageMaker notebook instances that contain sensitive information. Encryption and decryption are handled transparently by
-SageMaker, so no further modifications to the application are necessary.
            
-
            Sensitive Code Example
            
-
            For aws_cdk.aws_sagemaker.CfnNotebookInstance:
            
-
            +
            Amazon SageMaker notebook instances can process sensitive data, such as personal information, and should encrypt this data at rest.
            
+
            Why is this an issue?
            
+
            Amazon SageMaker notebook instances can process potentially sensitive data, such as personal information, as part of machine learning workflows. By
+default, SageMaker notebook instances do not encrypt data stored on the instance’s storage volume. This rule raises an issue when a notebook instance
+is created without a KMS key configured for encryption at rest.
            
+
            What is the potential impact?
            
+
            Exposure of sensitive data
            
+
            When a SageMaker notebook instance is not encrypted, an attacker who gains access to the underlying storage media can read all data stored on it in
+plaintext. This includes training datasets, model artifacts, credentials, and any other sensitive information processed during machine learning
+workflows.
            
+
            How to fix it
            
+
            Code examples
            
+
            The following code is vulnerable because the SageMaker notebook instance is created without specifying a KMS key, leaving data stored on the
+instance’s storage volume unencrypted.
            
+
            Noncompliant code example
            
+
             from aws_cdk import (
     aws_sagemaker as sagemaker
 )
@@ -23,15 +23,13 @@ 
            Sensitive Code Example
            
         super().__init__(scope, construct_id, **kwargs)
 
         sagemaker.CfnNotebookInstance(
-            self, "Sensitive",
+            self, "Example",
             instance_type="instanceType",
             role_arn="roleArn"
-        )  # Sensitive, no KMS key is set by default; thus, encryption is disabled
+        )  # Noncompliant: no KMS key is set by default; thus, encryption is disabled
 
            
-
            Compliant Solution
            
-
            For aws_cdk.aws_sagemaker.CfnNotebookInstance:
            
-
            +
            Compliant solution
            
+
             from aws_cdk import (
     aws_sagemaker as sagemaker,
     aws_kms as kms
@@ -43,16 +41,22 @@ 
            Compliant Solution
            
 
         my_key = kms.Key(self, "Key")
         sagemaker.CfnNotebookInstance(
-            self, "Compliant",
+            self, "Example",
             instance_type="instanceType",
             role_arn="roleArn",
             kms_key_id=my_key.key_id
         )
 
            
-
            See
            
+
            Resources
            
+
            Documentation
            
 
+
            Standards
            
+
              
+  
            • CWE - CWE-312 - Cleartext Storage of Sensitive Information
              • 
   
            • STIG Viewer - Application Security and
   Development: V-222588 - The application must implement approved cryptographic mechanisms to prevent unauthorized modification of information at
   rest.
              • 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6319.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6319.json
index a31c7071cf..5787724679 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6319.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6319.json
@@ -1,6 +1,7 @@
 {
-  "title": "Using unencrypted SageMaker notebook instances is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "SageMaker notebook instances should be encrypted at rest",
+  "type": "VULNERABILITY",
+  "quickfix": "unknown",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
@@ -14,7 +15,8 @@
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-6319",
@@ -22,7 +24,7 @@
   "scope": "All",
   "securityStandards": {
     "CWE": [
-      311
+      312
     ],
     "PCI DSS 3.2": [
       "2.2",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6327.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6327.html
index 36c61d00ae..a7ac3e19f2 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6327.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6327.html
@@ -1,42 +1,18 @@
-
              Amazon Simple Notification Service (SNS) is a managed messaging service for application-to-application (A2A) and application-to-person (A2P)
-communication. SNS topics allows publisher systems to fanout messages to a large number of subscriber systems. Amazon SNS allows to encrypt messages
-when they are received. In the case that adversaries gain physical access to the storage medium or otherwise leak a message they are not able to
-access the data.
              
-
              Ask Yourself Whether
              
-
                
-  
              • The topic contains sensitive data that could cause harm when leaked.
                • 
-  
              • There are compliance requirements for the service to store data encrypted.
                • 
-
              
-
              There is a risk if you answered yes to any of those questions.
              
-
              Recommended Secure Coding Practices
              
-
              It is recommended to encrypt SNS topics that contain sensitive information.
              
-
              To do so, create a master key and assign the SNS topic to it. Note that this system does not encrypt the following:
              
-
                
-  
              • Topic metadata (topic name and attributes)
                • 
-  
              • Message metadata (subject, message ID, timestamp, and attributes)
                • 
-  
              • Data protection policy
                • 
-  
              • Per-topic metrics
                • 
-
              
-
              Then, make sure that any publishers have the kms:GenerateDataKey* and kms:Decrypt permissions for the AWS KMS key.
              
-
              See AWS SNS Key Management
-Documentation for more information.
              
-
              Sensitive Code Example
              
-
              For aws_cdk.aws_sns.Topic:
              
-
              -from aws_cdk import (
-    aws_sns as sns
-)
-
-class TopicStack(Stack):
-    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
-        super().__init__(scope, construct_id, **kwargs)
-        sns.Topic( # Sensitive, unencrypted by default
-            self,
-            "example"
-        )
-
              
-
              For aws_cdk.aws_sns.CfnTopic:
              
-
              +
              Amazon Simple Notification Service (SNS) is a managed messaging service that supports server-side encryption (SSE) to protect messages stored at
+rest.
              
+
              Why is this an issue?
              
+
              Amazon SNS topics do not enable server-side encryption by default. When encryption is not configured, messages stored in SNS topics remain in
+plaintext, making them readable to anyone who gains unauthorized access to the underlying storage. This rule raises an issue when an SNS topic is
+created without a KMS master key configured.
              
+
              What is the potential impact?
              
+
              Sensitive data exposure
              
+
              If an attacker gains unauthorized access to the underlying storage medium, they can read the contents of SNS messages in plaintext. Depending on
+the data carried by the messages, this may expose sensitive information such as user data, financial records, or internal communications.
              
+
              How to fix it
              
+
              Code examples
              
+
              The following code creates an SNS topic without a KMS master key configured, leaving messages stored at rest unencrypted.
              
+
              Noncompliant code example
              
+
               from aws_cdk import (
     aws_sns as sns
 )
@@ -44,14 +20,13 @@ 
              Sensitive Code Example
              
 class TopicStack(Stack):
     def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
         super().__init__(scope, construct_id, **kwargs)
-        sns.CfnTopic( # Sensitive, unencrypted by default
+        sns.Topic( # Noncompliant: unencrypted by default
             self,
             "example"
         )
 
              
-
              Compliant Solution
              
-
              For aws_cdk.aws_sns.Topic:
              
-
              +
              Compliant solution
              
+
               from aws_cdk import (
     aws_sns as sns
 )
@@ -66,27 +41,20 @@ 
              Compliant Solution
              
             master_key=my_key
         )
 
              
-
              For aws_cdk.aws_sns.CfnTopic:
              
-
              -from aws_cdk import (
-    aws_sns as sns
-)
-
-class TopicStack(Stack):
-    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
-        super().__init__(scope, construct_id, **kwargs)
-        my_key = kms.Key(self, "key")
-        sns.CfnTopic(
-            self,
-            "example",
-            kms_master_key_id=my_key.key_id
-        )
-
              
-
              See
              
+
              The same fix applies to CfnTopic: pass the KMS key via the kms_master_key_id parameter.
              
+
              Resources
              
+
              Documentation
              
 
+
              Articles & blog posts
              
+
                
+  
              • AWS Blog - Encrypting messages
+  published to Amazon SNS with AWS KMS
                • 
+
              
+
              Standards
              
+
                
   
              • CWE - CWE-311 - Missing Encryption of Sensitive Data
                • 
   
              • STIG Viewer - Application Security and
   Development: V-222588 - The application must implement approved cryptographic mechanisms to prevent unauthorized modification of information at
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6327.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6327.json
index 1d54cb39c3..298a08d697 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6327.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6327.json
@@ -1,22 +1,24 @@
 {
-  "title": "Using unencrypted SNS topics is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Amazon SNS topics should be encrypted at rest",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
-      "SECURITY": "MEDIUM"
+      "SECURITY": "LOW"
     },
     "attribute": "TRUSTWORTHY"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "45min"
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
-  "defaultSeverity": "Major",
+  "defaultSeverity": "Minor",
   "ruleSpecification": "RSPEC-6327",
   "sqKey": "S6327",
   "scope": "All",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6329.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6329.html
index ee79c626ce..7619b8591c 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6329.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6329.html
@@ -1,193 +1,71 @@
 
                Enabling public network access to cloud resources can affect an organization’s ability to protect its data or internal operations from data theft
 or disruption.
                
-
                Depending on the component, inbound access from the Internet can be enabled via:
                
-
                  
-  
                • a boolean value that explicitly allows access to the public network.
                  • 
-  
                • the assignment of a public IP address.
                  • 
-  
                • database firewall rules that allow public IP ranges.
                  • 
-
                
-
                Deciding to allow public access may happen for various reasons such as for quick maintenance, time saving, or by accident.
                
-
                This decision increases the likelihood of attacks on the organization, such as:
                
-
                  
-  
                • data breaches.
                  • 
-  
                • intrusions into the infrastructure to permanently steal from it.
                  • 
-  
                • and various malicious traffic, such as DDoS attacks.
                  • 
-
                
-
                Ask Yourself Whether
                
-
                This cloud resource:
                
-
                  
-  
                • should be publicly accessible to any Internet user.
                  • 
-  
                • requires inbound traffic from the Internet to function properly.
                  • 
-
                
-
                There is a risk if you answered no to any of those questions.
                
-
                Recommended Secure Coding Practices
                
-
                Avoid publishing cloud services on the Internet unless they are intended to be publicly accessible, such as customer portals or e-commerce
-sites.
                
-
                Use private networks (and associated private IP addresses) and VPC peering or other secure communication tunnels to communicate with other cloud
-components.
                
-
                The goal is to prevent the component from intercepting traffic coming in via the public IP address. If the cloud resource does not support the
-absence of a public IP address, assign a public IP address to it, but do not create listeners for the public IP address.
                
-
                Sensitive Code Example
                
-
                For aws_cdk.aws_ec2.Instance and similar constructs:
                
-
                +
                Why is this an issue?
                
+
                Cloud resources that are exposed to the public Internet are reachable by any user worldwide. Inbound access from the Internet can be enabled in
+several ways: a property that explicitly allows access to the public network, the assignment of a public IP address, or firewall rules that include
+public IP ranges.
                
+
                Choosing to allow public access often happens for quick maintenance, time savings, or by accident. However, doing so significantly increases the
+attack surface of the resource and the organization that hosts it.
                
+
                This rule covers AWS CDK constructs for EC2 instances (aws_ec2.Instance, aws_ec2.CfnInstance), DMS replication instances
+(aws_dms.CfnReplicationInstance), and RDS database instances (aws_rds.DatabaseInstance,
+aws_rds.CfnDBInstance).
                
+
                What is the potential impact?
                
+
                A cloud resource that is publicly reachable is a direct target for attackers anywhere on the Internet. The most likely consequences are data
+breaches, intrusions that can be used to permanently compromise the infrastructure, and exposure to various forms of malicious traffic such as DDoS
+attacks.
                
+
                How to fix it
                
+
                Code examples
                
+
                The following code configures a cloud resource so that it is reachable from the public Internet, exposing it to unsolicited inbound traffic.
                
+
                Noncompliant code example
                
+
                 from aws_cdk import aws_ec2 as ec2
 
 ec2.Instance(
     self,
-    "vpc_subnet_public",
+    "vpc_subnet_example",
     instance_type=nano_t2,
     machine_image=ec2.MachineImage.latest_amazon_linux(),
     vpc=vpc,
-    vpc_subnets=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC) # Sensitive
-)
-
                
-
                For aws_cdk.aws_ec2.CfnInstance:
                
-
                -from aws_cdk import aws_ec2 as ec2
-
-ec2.CfnInstance(
-    self,
-    "cfn_public_exposed",
-    instance_type="t2.micro",
-    image_id="ami-0ea0f26a6d50850c5",
-    network_interfaces=[
-        ec2.CfnInstance.NetworkInterfaceProperty(
-            device_index="0",
-            associate_public_ip_address=True, # Sensitive
-            delete_on_termination=True,
-            subnet_id=vpc.select_subnets(subnet_type=ec2.SubnetType.PUBLIC).subnet_ids[0]
-        )
-    ]
-)
-
                
-
                For aws_cdk.aws_dms.CfnReplicationInstance:
                
-
                -from aws_cdk import aws_dms as dms
-
-rep_instance = dms.CfnReplicationInstance(
-    self,
-    "explicit_public",
-    replication_instance_class="dms.t2.micro",
-    allocated_storage=5,
-    publicly_accessible=True, # Sensitive
-    replication_subnet_group_identifier=subnet_group.replication_subnet_group_identifier,
-    vpc_security_group_ids=[vpc.vpc_default_security_group]
-)
-
                
-
                For aws_cdk.aws_rds.CfnDBInstance:
                
-
                -from aws_cdk import aws_rds as rds
-from aws_cdk import aws_ec2 as ec2
-
-rds_subnet_group_public = rds.CfnDBSubnetGroup(
-    self,
-    "public_subnet",
-    db_subnet_group_description="Subnets",
-    subnet_ids=vpc.select_subnets(
-        subnet_type=ec2.SubnetType.PUBLIC
-    ).subnet_ids
-)
-
-rds.CfnDBInstance(
-    self,
-    "public-public-subnet",
-    engine="postgres",
-    master_username="foobar",
-    master_user_password="12345678",
-    db_instance_class="db.r5.large",
-    allocated_storage="200",
-    iops=1000,
-    db_subnet_group_name=rds_subnet_group_public.ref,
-    publicly_accessible=True, # Sensitive
-    vpc_security_groups=[sg.security_group_id]
+    vpc_subnets=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC) # Noncompliant
 )
 
                
-
                Compliant Solution
                
-
                For aws_cdk.aws_ec2.Instance:
                
-
                +
                Compliant solution
                
+
                 from aws_cdk import aws_ec2 as ec2
 
 ec2.Instance(
     self,
-    "vpc_subnet_private",
+    "vpc_subnet_example",
     instance_type=nano_t2,
     machine_image=ec2.MachineImage.latest_amazon_linux(),
     vpc=vpc,
-    vpc_subnets=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PRIVATE_WITH_NAT)
-)
-
                
-
                For aws_cdk.aws_ec2.CfnInstance:
                
-
                -from aws_cdk import aws_ec2 as ec2
-
-ec2.CfnInstance(
-    self,
-    "cfn_private",
-    instance_type="t2.micro",
-    image_id="ami-0ea0f26a6d50850c5",
-    network_interfaces=[
-        ec2.CfnInstance.NetworkInterfaceProperty(
-            device_index="0",
-            associate_public_ip_address=False, # Compliant
-            delete_on_termination=True,
-            subnet_id=vpc.select_subnets(subnet_type=ec2.SubnetType.PRIVATE_WITH_NAT).subnet_ids[0]
-        )
-    ]
-)
-
                
-
                For aws_cdk.aws_dms.CfnReplicationInstance:
                
-
                -from aws_cdk import aws_dms as dms
-
-rep_instance = dms.CfnReplicationInstance(
-    self,
-    "explicit_private",
-    replication_instance_class="dms.t2.micro",
-    allocated_storage=5,
-    publicly_accessible=False,
-    replication_subnet_group_identifier=subnet_group.replication_subnet_group_identifier,
-    vpc_security_group_ids=[vpc.vpc_default_security_group]
+    vpc_subnets=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS)
 )
 
                
-
                For aws_cdk.aws_rds.CfnDBInstance:
                
-
                -from aws_cdk import aws_rds as rds
-from aws_cdk import aws_ec2 as ec2
-
-rds_subnet_group_private = rds.CfnDBSubnetGroup(
-    self,
-    "private_subnet",
-    db_subnet_group_description="Subnets",
-    subnet_ids=vpc.select_subnets(
-        subnet_type=ec2.SubnetType.PRIVATE_WITH_NAT
-    ).subnet_ids
-)
-
-rds.CfnDBInstance(
-    self,
-    "private-private-subnet",
-    engine="postgres",
-    master_username="foobar",
-    master_user_password="12345678",
-    db_instance_class="db.r5.large",
-    allocated_storage="200",
-    iops=1000,
-    db_subnet_group_name=rds_subnet_group_private.ref,
-    publicly_accessible=False,
-    vpc_security_groups=[sg.security_group_id]
-)
-
                
-
                See
                
+
                Resources
                
+
                Documentation
                
 
+
                Standards
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6329.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6329.json
index 2b8502617e..e84423cab7 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6329.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6329.json
@@ -1,6 +1,6 @@
 {
-  "title": "Allowing public network access to cloud resources is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Public network access to cloud resources should be disabled",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "BLOCKER"
@@ -8,13 +8,15 @@
     "attribute": "COMPLETE"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
-    "constantCost": "5min"
+    "constantCost": "30min"
   },
   "tags": [
     "cwe",
-    "aws"
+    "aws",
+    "former-hotspot"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-6329",
@@ -23,7 +25,9 @@
   "securityStandards": {
     "CWE": [
       284,
-      668
+      668,
+      732,
+      1327
     ],
     "PCI DSS 3.2": [
       "6.5.8"
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6330.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6330.html
index 6bdf709096..d430f3736e 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6330.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6330.html
@@ -1,18 +1,17 @@
-
                Amazon Simple Queue Service (SQS) is a managed message queuing service for application-to-application (A2A) communication. Amazon SQS can store
-messages encrypted as soon as they are received. In the case that adversaries gain physical access to the storage medium or otherwise leak a message
-from the file system, for example through a vulnerability in the service, they are not able to access the data.
                
-
                Ask Yourself Whether
                
-
                  
-  
                • The queue contains sensitive data that could cause harm when leaked.
                  • 
-  
                • There are compliance requirements for the service to store data encrypted.
                  • 
-
                
-
                There is a risk if you answered yes to any of those questions.
                
-
                Recommended Secure Coding Practices
                
-
                It’s recommended to encrypt SQS queues that contain sensitive information. Encryption and decryption are handled transparently by SQS, so no
-further modifications to the application are necessary.
                
-
                Sensitive Code Example
                
+
                Amazon SQS queues should be encrypted to protect sensitive message data at rest.
                
+
                Why is this an issue?
                
+
                Amazon Simple Queue Service (SQS) is a managed message queuing service for application-to-application communication. SQS can store messages
+encrypted as soon as they are received. This rule raises an issue when an SQS queue is created with encryption explicitly disabled.
                
+
                What is the potential impact?
                
+
                If an adversary gains physical access to the storage medium or otherwise reads a message from the file system, for example through a vulnerability
+in the service, they can access the data. This could result in the exposure of sensitive information such as personal data, credentials, or
+business-critical messages.
                
+
                How to fix it
                
+
                Code examples
                
+
                Encryption and decryption are handled transparently by SQS, so no further modifications to the application are necessary.
                
+
                Noncompliant code example
                
 
                For aws_cdk.aws_sqs.CfnQueue:
                
-
                +
                 from aws_cdk import (
     aws_sqs as sqs
 )
@@ -23,12 +22,12 @@ 
                Sensitive Code Example
                
         sqs.CfnQueue(
             self,
             "example",
-            sqs_managed_sse_enabled=False # Sensitive, unencrypted
+            sqs_managed_sse_enabled=False # Noncompliant, unencrypted
         )
 
                
-
                Compliant Solution
                
+
                Compliant solution
                
 
                For aws_cdk.aws_sqs.CfnQueue:
                
-
                +
                 from aws_cdk import (
     aws_sqs as sqs
 )
@@ -42,10 +41,14 @@ 
                Compliant Solution
                
             sqs_managed_sse_enabled=True
         )
 
                
-
                See
                
+
                Resources
                
+
                Documentation
                
 
+
                Standards
                
+
                  
   
                • CWE - CWE-311 - Missing Encryption of Sensitive Data
                  • 
   
                • STIG Viewer - Application Security and
   Development: V-222588 - The application must implement approved cryptographic mechanisms to prevent unauthorized modification of information at
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6330.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6330.json
index b73362c491..111be6bfda 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6330.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6330.json
@@ -1,6 +1,6 @@
 {
-  "title": "Using unencrypted SQS queues is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "SQS queues should be encrypted",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
@@ -14,12 +14,14 @@
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-6330",
   "sqKey": "S6330",
   "scope": "All",
+  "quickfix": "unknown",
   "securityStandards": {
     "CWE": [
       311
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6332.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6332.html
index 82af6348c7..c4d18e5c15 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6332.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6332.html
@@ -1,19 +1,18 @@
+
                  Amazon Elastic File System (EFS) file systems should be encrypted to protect sensitive data at rest.
                  
+
                  Why is this an issue?
                  
 
                  Amazon Elastic File System (EFS) is a serverless file system that does not require provisioning or managing storage. Stored files can be
-automatically encrypted by the service. In the case that adversaries gain physical access to the storage medium or otherwise leak a message they are
-not able to access the data.
                  
-
                  Ask Yourself Whether
                  
-
                    
-  
                  • The file system contains sensitive data that could cause harm when leaked.
                    • 
-  
                  • There are compliance requirements for the service to store data encrypted.
                    • 
-
                  
-
                  There is a risk if you answered yes to any of those questions.
                  
-
                  Recommended Secure Coding Practices
                  
-
                  It’s recommended to encrypt EFS file systems that contain sensitive information. Encryption and decryption are handled transparently by EFS, so no
-further modifications to the application are necessary.
                  
-
                  Sensitive Code Example
                  
-
                  For aws_cdk.aws_efs.FileSystem and aws_cdk.aws_efs.CfnFileSystem:
                  
-
                  +automatically encrypted by the service, but this feature is not always enabled by default. This rule raises an issue when an EFS file system is
+created with encryption disabled.
                  
+
                  What is the potential impact?
                  
+
                  If adversaries gain physical access to the storage medium or otherwise read data from the file system, for example through a vulnerability in the
+service, they can access the data. This could result in the exposure of sensitive information such as personal data, credentials, or business-critical
+files.
                  
+
                  How to fix it
                  
+
                  Code examples
                  
+
                  Encryption and decryption are handled transparently by EFS, so no further modifications to the application are necessary.
                  
+
                  Noncompliant code example
                  
+
                  For aws_cdk.aws_efs.FileSystem:
                  
+
                   from aws_cdk import (
     aws_efs as efs
 )
@@ -21,13 +20,12 @@ 
                  Sensitive Code Example
                  
 efs.FileSystem(
     self,
     "example",
-    encrypted=False  # Sensitive
+    encrypted=False  # Noncompliant
 )
 
                  
-
                  Compliant Solution
                  
-
                  For aws_cdk.aws_efs.FileSystem and aws_cdk.aws_efs.CfnFileSystem:
                  
-
                  +
                  Compliant solution
                  
+
                  For aws_cdk.aws_efs.FileSystem:
                  
+
                   from aws_cdk import (
     aws_efs as efs
 )
@@ -38,9 +36,13 @@ 
                  Compliant Solution
                  
     encrypted=True
 )
 
                  
-
                  See
                  
+
                  Resources
                  
+
                  Documentation
                  
 
+
                  Standards
                  
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6332.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6332.json
index b138952083..03927add5f 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6332.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6332.json
@@ -1,6 +1,6 @@
 {
-  "title": "Using unencrypted EFS file systems is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Amazon EFS file systems should be encrypted",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
@@ -14,12 +14,14 @@
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-6332",
   "sqKey": "S6332",
   "scope": "All",
+  "quickfix": "unknown",
   "securityStandards": {
     "CWE": [
       311
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6333.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6333.html
index 0023c29e22..e3689bf1d4 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6333.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6333.html
@@ -1,89 +1,82 @@
-
                  Creating APIs without authentication unnecessarily increases the attack surface on the target infrastructure.
                  
-
                  Unless another authentication method is used, attackers have the opportunity to attempt attacks against the underlying API.
-  
                  
-  This means attacks both on the functionality provided by the API and its infrastructure.
                  
-
                  Ask Yourself Whether
                  
-
                    
-  
                  • The underlying API exposes all of its contents to any anonymous Internet user.
                    • 
-
                  
-
                  There is a risk if you answered yes to this question.
                  
-
                  Recommended Secure Coding Practices
                  
-
                  In general, prefer limiting API access to a specific set of people or entities.
                  
-
                  AWS provides multiple methods to do so:
                  
-
                    
-  
                  • AWS_IAM, to use standard AWS IAM roles and policies.
                    • 
-  
                  • COGNITO_USER_POOLS, to use customizable OpenID Connect (OIDC) identity providers (IdP).
                    • 
-  
                  • CUSTOM, to use an AWS-independant OIDC provider, glued to the infrastructure with a Lambda authorizer.
                    • 
-
                  
-
                  Sensitive Code Example
                  
+
                  Creating AWS API Gateway resources without enforcing authentication exposes the underlying API to any anonymous internet user.
                  
+
                  Why is this an issue?
                  
+
                  Unless an authentication method is explicitly configured, AWS API Gateway allows any internet user to call the API without proving their identity.
+This unnecessarily increases the attack surface, giving unauthenticated actors the opportunity to target both the functionality provided by the API
+and its underlying infrastructure.
                  
+
                  What is the potential impact?
                  
+
                  Unauthorized access
                  
+
                  An unauthenticated API endpoint can be reached by any internet user without proving their identity. Attackers may abuse the exposed functionality
+to extract sensitive data, trigger resource-intensive operations, or exploit other vulnerabilities in the backend infrastructure.
                  
+
                  How to fix it in AWS API Gateway
                  
+
                  Code examples
                  
+
                  The following examples show API Gateway resources configured without authentication, allowing access by any internet user.
                  
 
                  For aws_cdk.aws_apigateway.Resource:
                  
-
                  +
                  Noncompliant code example
                  
+
                   from aws_cdk import (
     aws_apigateway as apigateway
 )
 
 resource = api.root.add_resource("example")
 resource.add_method(
-    "GET",
-    authorization_type=apigateway.AuthorizationType.NONE  # Sensitive
-)
-
                  
-
                  For aws_cdk.aws_apigatewayv2.CfnRoute:
                  
-
                  -from aws_cdk import (
-    aws_apigatewayv2 as apigateway
-)
-
-apigateway.CfnRoute(
-    self,
-    "no-auth",
-    api_id=api.ref,
-    route_key="GET /test",
-    authorization_type="NONE"  # Sensitive
+    "POST",
+    authorization_type=apigateway.AuthorizationType.NONE  # Noncompliant
 )
 
                  
-
                  Compliant Solution
                  
-
                  For aws_cdk.aws_apigateway.Resource:
                  
-
                  +
                  Compliant solution
                  
+
                   from aws_cdk import (
     aws_apigateway as apigateway
 )
 
-opts = apigateway.MethodOptions(
-    authorization_type=apigateway.AuthorizationType.IAM
-)
-resource = api.root.add_resource(
-    "example",
-    default_method_options=opts
-)
+resource = api.root.add_resource("example")
 resource.add_method(
     "POST",
     authorization_type=apigateway.AuthorizationType.IAM
 )
-resource.add_method(  # authorization_type is inherited from the Resource's configured default_method_options
-    "POST"
-)
 
                  
+
                  How to fix it in AWS API Gateway V2
                  
+
                  Code examples
                  
+
                  The following examples show API Gateway resources configured without authentication, allowing access by any internet user.
                  
 
                  For aws_cdk.aws_apigatewayv2.CfnRoute:
                  
-
                  +
                  Noncompliant code example
                  
+
                  +from aws_cdk import (
+    aws_apigatewayv2 as apigateway
+)
+
+apigateway.CfnRoute(
+    self,
+    "update",
+    api_id=api.ref,
+    route_key="POST /update",
+    authorization_type="NONE"  # Noncompliant
+)
+
                  
+
                  Compliant solution
                  
+
                   from aws_cdk import (
     aws_apigatewayv2 as apigateway
 )
 
 apigateway.CfnRoute(
     self,
-    "auth",
+    "update",
     api_id=api.ref,
-    route_key="GET /test",
+    route_key="POST /update",
     authorization_type="AWS_IAM"
 )
 
                  
-
                  See
                  
+
                  Resources
                  
+
                  Documentation
                  
 
+
                  Standards
                  
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6333.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6333.json
index 31f549fd2b..c117decd19 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6333.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6333.json
@@ -1,6 +1,6 @@
 {
-  "title": "Creating public APIs is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "AWS API Gateway should require authentication",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "BLOCKER"
@@ -8,13 +8,15 @@
     "attribute": "COMPLETE"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "15min"
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-6333",
@@ -22,7 +24,7 @@
   "scope": "Main",
   "securityStandards": {
     "CWE": [
-      284
+      306
     ],
     "PCI DSS 3.2": [
       "6.5.8"
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6418.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6418.html
index 17ef587189..62c5e68bba 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6418.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6418.html
@@ -66,7 +66,9 @@ 
                  Resources
                  
   
                • OWASP - Top 10 2017 Category A2 - Broken
   Authentication
                  • 
   
                • CWE - CWE-798 - Use of Hard-coded Credentials
                  • 
-  
                • MSC - MSC03-J - Never hard code sensitive information
                  • 
+  
                • MSC - MSC03-J - Never
+  hard code sensitive information
                  • 
   
                • AWS Secrets Manager - Code
   Examples
                  • 
   
                • Azure Key Vault - Quickstart
                  • 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6418.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6418.json
index f7e397a71d..47b33fc8be 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6418.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6418.json
@@ -14,7 +14,9 @@
   },
   "quickfix": "infeasible",
   "tags": [
-    "cwe"
+    "cwe",
+    "former-hotspot",
+    "secret"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-6418",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6437.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6437.json
index 757d768d07..70c5fa9904 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6437.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6437.json
@@ -13,7 +13,8 @@
     "constantCost": "60min"
   },
   "tags": [
-    "cwe"
+    "cwe",
+    "secret"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-6437",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6463.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6463.html
index b4ea905ce9..f24a436ed0 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6463.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6463.html
@@ -1,36 +1,34 @@
-
                  Allowing unrestricted outbound communications can lead to data leaks.
                  
+
                  Allowing unrestricted outbound communications from a security group can enable compromised resources to exfiltrate data or communicate with
+attacker-controlled servers.
                  
+
                  Why is this an issue?
                  
 
                  When a security group allows all outbound communications, applications or services within the security group can send data to any external IP
 address or port without restriction. If a resource within the security group becomes compromised, attackers could send malicious traffic or exfiltrate
-data to external servers. This could happen even if the resource is not directly exposed to the internet, such as in case of a supply chain
-attack.
                  
-
                  When deciding if outgoing connections should be limited, consider that limiting the connections results in additional administration and
-maintenance work.
                  
-
                  Ask Yourself Whether
                  
-
                    
-  
                  • The resource has access to sensitive data.
                    • 
-  
                  • The resource is part of a private network.
                    • 
-
                  
-
                  There is a risk if you answered yes to any of those questions.
                  
-
                  Recommended Secure Coding Practices
                  
-
                  The principles of defence-in-depth and least privilege suggest that outbound connections should be restricted to a set of trusted destinations.
                  
-
                  Consider restricting the security group egress rules so that it can only contact specific locations, such as trusted IP address ranges or other
-security groups. If any resources require unrestricted outbound access, place them in their own security group.
                  
-
                  Sensitive Code Example
                  
-
                  For aws_cdk.aws_ec2.SecurityGroup:
                  
-
                  +data to external servers. This risk exists even if the resource is not directly exposed to the internet, such as a supply chain attack.
                  
+
                  What is the potential impact?
                  
+
                  Data exfiltration
                  
+
                  If a resource within the security group becomes compromised, unrestricted outbound access allows an attacker to silently send sensitive data such
+as credentials or database contents to external servers.
                  
+
                  Malicious traffic propagation
                  
+
                  A compromised resource can use unrestricted outbound access to communicate with attacker-controlled command-and-control servers or participate in
+DDoS attacks, probe internal network segments, or spread malware to other hosts.
                  
+
                  How to fix it
                  
+
                  Code examples
                  
+
                  The following code example is vulnerable because the allow_all_outbound parameter is not explicitly set to False, which
+causes the security group to allow all outbound traffic by default.
                  
+
                  Noncompliant code example
                  
+
                   from aws_cdk import (
     aws_ec2 as ec2
 )
 
-ec2.SecurityGroup(  # Sensitive; allow_all_outbound is enabled by default
+ec2.SecurityGroup(  # Noncompliant: allow_all_outbound is enabled by default
     self,
     "example",
     vpc=vpc
 )
 
                  
-
                  Compliant Solution
                  
-
                  For aws_cdk.aws_ec2.SecurityGroup:
                  
-
                  +
                  Compliant solution
                  
+
                   from aws_cdk import (
     aws_ec2 as ec2
 )
@@ -47,10 +45,15 @@ 
                  Compliant Solution
                  
     connection=ec2.Port.tcp(443)
 )
 
                  
-
                  See
                  
+
                  Resources
                  
+
                  Documentation
                  
 
+
                  Standards
                  
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6463.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6463.json
index ca27b4e56c..a072a09e67 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6463.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6463.json
@@ -1,6 +1,6 @@
 {
-  "title": "Allowing unrestricted outbound communications is security-sensitive",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Security groups should not allow unrestricted outbound traffic",
+  "type": "VULNERABILITY",
   "code": {
     "impacts": {
       "SECURITY": "MEDIUM"
@@ -8,13 +8,15 @@
     "attribute": "COMPLETE"
   },
   "status": "ready",
+  "quickfix": "unknown",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "60min"
   },
   "tags": [
     "aws",
-    "cwe"
+    "cwe",
+    "former-hotspot"
   ],
   "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-6463",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6781.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6781.json
index d0c729cd6b..935b504816 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6781.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6781.json
@@ -13,7 +13,8 @@
     "constantCost": "30min"
   },
   "tags": [
-    "cwe"
+    "cwe",
+    "secret"
   ],
   "defaultSeverity": "Blocker",
   "ruleSpecification": "RSPEC-6781",
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6863.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6863.html
index 8dbca05aae..0d8c6cd411 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6863.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6863.html
@@ -1,4 +1,4 @@
-
                  This is an issue when a Flask error handler returns a response without explicitly specifying the HTTP status code.
                  
+
                  This rule raises an issue when a Flask error handler returns a response without explicitly specifying the HTTP status code.
                  
 
                  Why is this an issue?
                  
 
                  Flask error handlers do not automatically set the HTTP status code based on the error type they handle. When you register an error handler with
 @app.errorhandler(404), Flask does not automatically return a 404 status code from that handler.
                  
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6984.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6984.html
index 8cc03d3534..5d9c32008b 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6984.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6984.html
@@ -1,7 +1,7 @@
 
                  This rule raises an issue when an incorrect pattern is provided to an einops operation.
                  
 
                  Why is this an issue?
                  
 
                  The einops library provides a powerful and flexible way to manipulate tensors using the Einstein summation convention. The
-einops uses a different convention than the traditional one. In particular, the axis names
+einops uses a different convention than the traditional one. In particular, the axis names
 can be more than one letter long and are separated by spaces.
                  
 
                  How to fix it
                  
 
                  Correct the syntax of the einops operation by balancing the parentheses and following the convention.
                  
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6985.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6985.html
index c584fd8267..93a68fcbb8 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6985.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6985.html
@@ -1,8 +1,12 @@
-
                  This rule raises an issue when pytorch.load is used to load a model.
                  
+
                  Loading serialized PyTorch models with torch.load without restricting deserialization can lead to arbitrary code execution.
                  
 
                  Why is this an issue?
                  
 
                  In PyTorch, it is common to load serialized models using the torch.load function. Under the hood, torch.load uses the
 pickle library to load the model and the weights. If the model comes from an untrusted source, an attacker could inject a malicious
 payload which would be executed during the deserialization.
                  
+
                  What is the potential impact?
                  
+
                  Remote code execution
                  
+
                  An attacker who controls a model file loaded with torch.load can execute arbitrary code on the target machine. This can lead to full
+system compromise, data exfiltration, or further lateral movement within a network.
                  
 
                  How to fix it
                  
 
                  Use a safer alternative to load the model, such as safetensors.torch.load_model. Alternatively, PyTorch can be instructed to only load
 the weights by setting the parameter weights_only=True. This avoids the use of the pickle library and is therefore safe.
@@ -12,7 +16,7 @@ 
                  Noncompliant code example
                  
 
                   import torch
 
-model = torch.load('model.pth') # Noncompliant: torch.load is used to load the model
+model = torch.load('model.pth') # Noncompliant
 
                  
 
                  Compliant solution
                  
 
                  @@ -25,7 +29,12 @@ 
                  Compliant solution
                  
 
                  Resources
                  
 
                  Documentation
                  
 
+
                  Standards
                  
+
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6985.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6985.json
index d21e3880fc..e6a94e4e2c 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6985.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S6985.json
@@ -1,14 +1,16 @@
 {
-  "title": "Usage of \"torch.load\" can lead to untrusted code execution",
-  "type": "SECURITY_HOTSPOT",
+  "title": "Models should not be loaded with \"torch.load\" without restricting deserialization",
+  "type": "VULNERABILITY",
   "status": "ready",
   "remediation": {
     "func": "Constant\/Issue",
     "constantCost": "15min"
   },
   "tags": [
+    "cwe",
     "pytorch",
-    "machine-learning"
+    "machine-learning",
+    "former-hotspot"
   ],
   "defaultSeverity": "Critical",
   "ruleSpecification": "RSPEC-6985",
@@ -23,7 +25,7 @@
   },
   "securityStandards": {
     "CWE": [
-      94,
+      913,
       502
     ]
   }
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S7503.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S7503.html
index 77b0a96837..3538587b64 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S7503.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S7503.html
@@ -16,6 +16,8 @@ 
                  Why is this an issue?
                  
 
                
 
                How to fix it
                
 
                Either remove the async keyword, or start using the appropriate asynchronous features.
                
+
                An async method may also need to remain awaitable to fulfil an inherited contract. In that case, make the contract explicit in the code, for
+example by inheriting from the relevant base class or protocol and marking the method as an override.
                
 
                Code examples
                
 
                Noncompliant code example
                
 
                @@ -41,6 +43,45 @@ 
                Compliant solution
                
 async def my_function():  # Compliant
     return await another_function()
 
                
+
                Exceptions
                
+
                This rule does not raise an issue in the following cases:
                
+
                  
+  
                • Abstract methods: Methods decorated with @abstractmethod or @abc.abstractmethod are often async to
+  signal an async contract for subclasses, even if the abstract body itself is empty.
                  • 
+  
                • Dunder methods: Special methods such as __aenter__, __aexit__, or __anext__ form part of
+  the async protocol interface and must be async regardless of their body.
                  • 
+  
                • Decorated functions: Decorators may change the function’s behavior in ways that make the async keyword meaningful
+  (e.g., framework route handlers).
                  • 
+  
                • Overriding methods: A method that overrides an async method from a parent class may legitimately be async to respect the
+  parent’s interface.
                  • 
+  
                • Trivial bodies: Functions whose body consists only of pass, …​, or raise statements are
+  considered stubs or placeholders and are not flagged.
                  • 
+  
                • Framework-required coroutine callbacks: Some frameworks require callbacks to be coroutines even when they don’t internally use
+  await. This rule recognizes the following cases:
+    
                    
+      
                  • httpx.AsyncClient event hooks registered under the "request" or "response" keys of the
+      event_hooks parameter.
                    • 
+      
                  • confluent_kafka.aio.AIOConsumer.subscribe callbacks passed as on_assign, on_revoke, or
+      on_lost keyword arguments.
                    • 
+    
                  • 
+
                
+
                +import httpx
+
+async def log_request(request: httpx.Request) -> None:  # Compliant - required coroutine callback
+    print(f"Request: {request.method} {request.url}")
+
+client = httpx.AsyncClient(event_hooks={"request": [log_request]})
+
                
+
                +from confluent_kafka.aio import AIOConsumer
+
+async def on_assign(consumer, partitions) -> None:  # Compliant - required coroutine callback
+    print(f"Assigned: {partitions}")
+
+consumer = AIOConsumer({"bootstrap.servers": "localhost:9092", "group.id": "mygroup"})
+await consumer.subscribe(["topic"], on_assign=on_assign)
+
                
 
                Resources
                
 
                Articles & blog posts
                
 
                  
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8392.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8392.html
index 1a9ba79a84..4409bf3ede 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8392.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8392.html
@@ -111,19 +111,18 @@ 
                  Documentation
                  
 
 
                  Standards
                  
 
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8392.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8392.json
index 2d94b8867f..716d03f3b8 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8392.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8392.json
@@ -28,9 +28,6 @@
   "securityStandards": {
     "CWE": [
       668
-    ],
-    "CIS": [
-      "6.6.1"
     ]
   }
 }
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8396.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8396.html
index 8a1c66cdd1..6c4f33a592 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8396.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8396.html
@@ -1,5 +1,5 @@
-
                  This is an issue when a Pydantic model field uses Optional[Type] or Type | None type hints without providing an explicit
-default value, or when using Field(…​) with the ellipsis operator.
                  
+
                  This is an issue when a Pydantic model field uses Optional[Type] without providing an explicit default value, or when using
+Field(…​) with Optional[Type] and the ellipsis operator.
                  
 
                  Why is this an issue?
                  
 
                  In Pydantic models, there is a common misconception about what Optional[Type] means. Many developers assume that marking a field as
 Optional[Type] makes it optional during validation, but this is not the case.
                  
@@ -9,14 +9,17 @@ 
                  Why is this an issue?
                  
 
                  To make a field truly optional (meaning it doesn’t need to be provided during validation), you must assign a default value. This is typically
 None for optional fields, but can be any appropriate default value.
                  
 
                  A particularly problematic pattern is using Field(…​) with Optional[Type]. The ellipsis (…​) is Pydantic’s
-way of explicitly marking a field as required. This creates a direct contradiction: the type hint says the field can be None, but the
-Field(…​) says it must be provided. In this case, Pydantic prioritizes the ellipsis, making the field required despite the
-Optional annotation.
                  
+way of explicitly marking a field as required. This creates a direct contradiction: the type hint says the field can be None, but
+Field(…​) says it must be provided.
                  
 
                  This mismatch between developer intent and actual behavior leads to unexpected validation errors in production, confusing API consumers who receive
 "field required" errors for fields they reasonably expected to be optional based on the type hints.
                  
+
                  Exceptions
                  
+
                  Fields typed as Type | None, None | Type, or Union[Type, None] are compliant, with or without a default
+value.
                  
+
                  These annotations are explicit nullable type declarations and do not imply that the field may be omitted from input data.
                  
 
                  What is the potential impact?
                  
-
                  When optional fields lack explicit default values, the application will reject valid requests where users omit fields they believe to be optional.
-This leads to:
                  
+
                  When Optional[…​] fields lack explicit default values, the application may reject requests where users omit fields they believe to be
+optional. This leads to:
                  
 
                    
   
                  • Poor user experience with confusing "field required" validation errors
                    • 
   
                  • API contract violations where the schema suggests fields are optional but validation requires them
                    • 
@@ -26,11 +29,12 @@ 
                    What is the potential impact?
                    
 
                    How to fix it
                    
 
                    Add an explicit default value (typically None) to fields with Optional type hints. This makes the field truly optional
 during validation while maintaining the type safety that allows None values.
                    
+
                    For Optional[…​] fields, avoid the ellipsis form (Field(…​)) and provide an explicit default instead.
                    
 
                    Code examples
                    
 
                    Noncompliant code example
                    
 
                     from typing import Optional
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 class TwitterAccount(BaseModel):
     username: str
@@ -42,8 +46,8 @@ 
                    Noncompliant code example
                    
 
                    
 
                    Compliant solution
                    
 
                    -from typing import Optional
-from pydantic import BaseModel
+from typing import Optional, Union
+from pydantic import BaseModel, Field
 
 class TwitterAccount(BaseModel):
     username: str
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8397.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8397.html
index 65c2a4d0d7..c68e8de9f6 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8397.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8397.html
@@ -69,11 +69,11 @@ 
                    Compliant solution
                    
 
                    Resources
                    
 
                    Documentation
                    
 
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8409.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8409.json
index d1334b904b..974b647f90 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8409.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8409.json
@@ -11,14 +11,14 @@
     "redundant",
     "api"
   ],
-  "defaultSeverity": "Blocker",
+  "defaultSeverity": "Minor",
   "ruleSpecification": "RSPEC-8409",
   "sqKey": "S8409",
   "scope": "Main",
   "quickfix": "unknown",
   "code": {
     "impacts": {
-      "MAINTAINABILITY": "BLOCKER"
+      "MAINTAINABILITY": "LOW"
     },
     "attribute": "CLEAR"
   }
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8410.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8410.html
index df74de4a63..e698a6f354 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8410.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8410.html
@@ -3,20 +3,19 @@
 
                    Why is this an issue?
                    
 
                    FastAPI originally allowed declaring dependencies by using them as default parameter values. While this approach still works, it has several
 drawbacks that make code harder to maintain and understand.
                    
-
                    When dependencies are declared as default values, the actual type of the parameter becomes ambiguous. For example, db =
-Depends(get_db) doesn’t clearly indicate what type db will be at runtime. This makes the code harder to read and reduces the
-effectiveness of IDE autocompletion and type checking tools.
                    
-
                    The modern Annotated syntax separates the type information from the dependency declaration, making both aspects explicit. This
-approach provides better clarity about what the parameter actually is, while still specifying how it should be injected.
                    
+
                    Using FastAPI functions such as Depends(), Query(), Path(), and Body() as parameter default
+values mixes two different concerns: the parameter’s actual Python default value and FastAPI’s request handling metadata.
                    
+
                    The modern Annotated syntax keeps the type and any real Python default value in their usual places, while still making the
+FastAPI-specific behavior explicit.
                    
 
                    Using Annotated consistently across your codebase also aligns with FastAPI’s current recommendations and ensures your code follows
 modern Python typing conventions introduced in Python 3.9.
                    
 
                    The old syntax mixes concerns by using the default value mechanism for dependency injection, which is semantically confusing since the "default"
 isn’t really a default value in the traditional sense.
                    
 
                    What is the potential impact?
                    
-
                    Using the deprecated syntax makes code less maintainable in several ways:
                    
+
                    Using this old syntax makes code less maintainable in several ways:
                    
 
                      
-  
                    • Type checkers and IDEs cannot accurately infer the actual runtime type of parameters, reducing the effectiveness of static analysis and
-  autocompletion
                      • 
+  
                    • The function’s default value no longer represents the real Python default value of the parameter
                      • 
+  
                    • If the function is called outside FastAPI, omitted arguments can produce FastAPI metadata objects instead of business values
                      • 
   
                    • Developers reading the code must mentally separate the dependency injection mechanism from the actual parameter type
                      • 
   
                    • Mixing old and new syntax across a codebase creates inconsistency that increases cognitive load
                      • 
   
                    • Future FastAPI versions may deprecate or remove support for the old syntax, requiring migration work
                      • 
@@ -24,34 +23,45 @@ 
                      What is the potential impact?
                      
 
                      How to fix it in FastAPI
                      
 
                      Replace dependency declarations in default values with Annotated type hints. Import Annotated from the
 typing module (Python 3.9+) or typing_extensions (Python 3.8 and earlier). The first argument to Annotated is
-the actual type of the parameter, and the second argument is the dependency injection specification.
                      
+the actual type of the parameter, and the second argument is the dependency injection specification. If the parameter has a real default value, keep
+it as the normal Python default after the annotation.
                      
 
                      Code examples
                      
 
                      Noncompliant code example
                      
 
                      +from dataclasses import dataclass
 from fastapi import Depends, FastAPI
 
 app = FastAPI()
 
-def get_db():
-    return "database_connection"
+@dataclass
+class User:
+    username: str
+
+def get_current_user() -> User:
+    return User(username="alice")
 
 @app.get("/items/")
-def read_items(db = Depends(get_db)):  # Noncompliant
-    return {"db": db}
+def read_items(user = Depends(get_current_user)):  # Noncompliant
+    return {"user": user.username}
 
                      
 
                      Compliant solution
                      
 
                      +from dataclasses import dataclass
 from typing import Annotated
 from fastapi import Depends, FastAPI
 
 app = FastAPI()
 
-def get_db():
-    return "database_connection"
+@dataclass
+class User:
+    username: str
+
+def get_current_user() -> User:
+    return User(username="alice")
 
 @app.get("/items/")
-def read_items(db: Annotated[str, Depends(get_db)]):
-    return {"db": db}
+def read_items(user: Annotated[User, Depends(get_current_user)]):
+    return {"user": user.username}
 
                      
 
                      The same pattern applies to query parameters, path parameters, and request body parameters. Use Annotated to combine the type with the
 parameter specification.
                      
@@ -63,7 +73,7 @@ 
                      Noncompliant code example
                      
 
 @app.get("/search/")
 def search_items(
-    q: str = Query(None, max_length=50)  # Noncompliant
+    q: str = Query("latest", max_length=50)  # Noncompliant
 ):
     return {"query": q}
 
                    
@@ -76,7 +86,7 @@ 
                    Compliant solution
                    
 
 @app.get("/search/")
 def search_items(
-    q: Annotated[str | None, Query(max_length=50)] = None
+    q: Annotated[str, Query(max_length=50)] = "latest"
 ):
     return {"query": q}
 
                
@@ -114,8 +124,8 @@ 
                Documentation
                
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8410.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8410.json
index c829f01348..6308815493 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8410.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8410.json
@@ -11,14 +11,14 @@
     "type-hint",
     "convention"
   ],
-  "defaultSeverity": "Blocker",
+  "defaultSeverity": "Minor",
   "ruleSpecification": "RSPEC-8410",
   "sqKey": "S8410",
   "scope": "Main",
   "quickfix": "unknown",
   "code": {
     "impacts": {
-      "MAINTAINABILITY": "BLOCKER"
+      "MAINTAINABILITY": "LOW"
     },
     "attribute": "CLEAR"
   }
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8411.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8411.html
index 0568b0ea31..e3f4bf3f93 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8411.html
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8411.html
@@ -1,39 +1,44 @@
-
                This is an issue when a FastAPI route decorator declares path parameters (e.g., @app.get("/items/{item_id}")) but the corresponding
-function signature does not include those parameters as arguments. It is also an issue when path parameters are declared as positional-only arguments
-(using / in the signature).
                
+
                This is an issue when a FastAPI route decorator declares path parameters (e.g., @app.get("/items/{item_id}")) but neither the route
+handler, called a path operation function in FastAPI, nor its dependencies declare those parameters as arguments. It is also an issue when path
+parameters are declared as positional-only arguments (using / in the signature).
                
 
                Why is this an issue?
                
 
                FastAPI is a modern web framework that uses Python type hints and function signatures to automatically extract, validate, and inject request
-parameters into route handler functions. When you define a route with path parameters in the decorator (e.g.,
-@app.get("/items/{item_id}")), FastAPI expects these parameters to be present in the function signature.
                
+parameters into route handlers and dependencies. FastAPI injects path values only into parameters with matching names declared by the path operation
+function or by one of its dependencies.
                
 
                Path parameters are segments of the URL path that are used to identify specific resources. For example, in the route /items/{item_id},
 the item_id is a path parameter that would capture values like 123 from a request to /items/123.
                
-
                The framework works by inspecting the function signature at startup and creating a mapping between the route path parameters and the function
-arguments. When a request comes in, FastAPI extracts the values from the URL path and injects them into the function call.
                
-
                When path parameters are missing from the function signature, several problems occur:
                
+
                The framework works by inspecting function signatures at startup and creating a mapping between route path parameters and path operation function
+or dependency parameters. When a request comes in, FastAPI extracts the values from the URL path and injects them into matching parameters by
+name.
                
+
                When path parameters are not declared by the path operation function or its dependencies, several problems can occur:
                
 
                  
-  
                •  The parameter values cannot be accessed in the function body, making it impossible to use them for business logic 
                  • 
-  
                •  FastAPI cannot perform automatic validation and type conversion on the parameter 
                  • 
-  
                •  The application will raise a runtime error when the route is accessed 
                  • 
-  
                •  The mismatch between the route definition and function signature indicates a programming error 
                  • 
+  
                • The route contract may require a path value that the application code never consumes
                  • 
+  
                • A misspelled or mismatched function parameter may be treated and validated as a query parameter instead of receiving the path value
                  • 
+  
                • If the mismatched parameter has a default value, the endpoint may silently ignore the path value
                  • 
+  
                • The mismatch between the route definition and function signature indicates a programming error
                  • 
 
                
 
                Additionally, if a path parameter is declared as a positional-only argument (using / in the function signature), FastAPI cannot inject
 it because the framework uses keyword arguments for parameter injection. This is a subtle but important constraint of how FastAPI’s dependency
 injection system works.
                
-
                This type of error is particularly problematic because it may not be caught during development if the specific route is not tested, leading to
-runtime failures in production.
                
+
                This type of error is problematic because it may not be caught during development if the specific route is not tested, leading to validation errors
+or incorrect endpoint behavior in production.
                
 
                What is the potential impact?
                
-
                When path parameters are missing from the function signature, the application will fail at runtime when the route is accessed. This causes:
                
+
                When path parameters are not declared by the path operation function or its dependencies, the endpoint contract no longer matches the code that
+handles the request. This can cause:
                
 
                  
-  
                •  Service disruption: The endpoint becomes completely non-functional, returning HTTP 500 errors to clients 
                  • 
-  
                •  Poor user experience: Users receive error responses instead of the expected data or functionality 
                  • 
-  
                •  Debugging difficulty: The error may not be immediately obvious, especially if the route is not covered by tests 
                  • 
-  
                •  Maintenance burden: Developers must spend time investigating and fixing runtime errors that could have been prevented 
                  • 
+  
                • Request validation errors: A wrongly named parameter may be interpreted as a required query parameter instead of the intended
+  path parameter
                  • 
+  
                • Incorrect behavior: The endpoint may ignore the value from the URL path and use a default value or unrelated input instead
                  • 
+  
                • Poor API contract clarity: The route path suggests that a value is required, but the handler does not consume it
                  • 
+  
                • Maintenance burden: Developers must spend time investigating and fixing runtime errors and mismatches that could have been
+  prevented
                  • 
 
                
-
                The impact is particularly severe because this is a complete failure of the endpoint - there is no graceful degradation or partial functionality.
-Every request to the affected route will fail until the code is corrected and redeployed.
                
+
                The impact depends on how the path operation function is written. Some mismatches cause immediate request failures, while others silently produce
+stale or misleading API behavior.
                
 
                How to fix it in FastAPI
                
-
                Include all path parameters from the route decorator in the function signature. The parameter names in the function must exactly match the
-parameter names in the route path (enclosed in curly braces). Add type hints to enable FastAPI’s automatic validation and conversion.
                
+
                Include all path parameters from the route decorator in the path operation function signature, or in the signature of a FastAPI dependency used by
+that route. The parameter names must match the parameter names in the route path (enclosed in curly braces). Add type hints to enable FastAPI’s
+automatic validation and conversion.
                
 
                Code examples
                
 
                Noncompliant code example
                
 
                @@ -124,13 +129,13 @@ 
                Compliant solution
                
 
                Resources
                
 
                Documentation
                
 
 
                Related rules
                
 
                  
-  
                •  {rule:python:S6856} - Similar rule for Java Spring framework path variables 
                  • 
+  
                • {rule:python:S6856} - Similar rule for Java Spring framework path variables
                  • 
 
                
 
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8411.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8411.json
index d37a38007a..72a85a67dd 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8411.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8411.json
@@ -1,5 +1,5 @@
 {
-  "title": "FastAPI path parameters should be included in route function signatures",
+  "title": "FastAPI path parameters should be declared in route handlers or dependencies",
   "type": "BUG",
   "status": "ready",
   "remediation": {
@@ -11,14 +11,14 @@
     "api",
     "pitfall"
   ],
-  "defaultSeverity": "Blocker",
+  "defaultSeverity": "Major",
   "ruleSpecification": "RSPEC-8411",
   "sqKey": "S8411",
   "scope": "Main",
   "quickfix": "unknown",
   "code": {
     "impacts": {
-      "RELIABILITY": "BLOCKER"
+      "RELIABILITY": "HIGH"
     },
     "attribute": "COMPLETE"
   }
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8490.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8490.html
new file mode 100644
index 0000000000..e10d0d6193
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8490.html
@@ -0,0 +1,51 @@
+
                This is an issue when a class inherits from Enum and is also decorated with @dataclass.
                
+
                Why is this an issue?
                
+
                The @dataclass decorator and Enum classes are incompatible and should not be used together.
                
+
                The @dataclass decorator automatically generates special methods like __init__, __repr__, and
+__eq__ for regular classes. It modifies the class definition to add these methods based on the class attributes.
                
+
                However, Enum classes use a special metaclass called EnumMeta that controls how enum members are created and behave. Enum
+members are not regular instances - they are singleton constants that are created when the class is defined.
                
+
                When you try to combine these two features, several problems occur:
                
+
                  
+  
                • The @dataclass decorator tries to modify the class in ways that conflict with the Enum metaclass
                  • 
+  
                • The automatic __init__ generation from @dataclass interferes with how Enum members are instantiated
                  • 
+  
                • At runtime, this typically results in a TypeError because the modifications are incompatible
                  • 
+
                
+
                Enums are designed to represent a fixed set of named constants, while dataclasses are meant to hold data with potentially varying values. These are
+fundamentally different purposes that should not be mixed.
                
+
                What is the potential impact?
                
+
                This code pattern will cause a TypeError at runtime when Python attempts to create the class. The application will fail to start or
+the module will fail to import, preventing the code from running at all.
                
+
                This is a critical reliability issue that blocks normal program execution.
                
+
                How to fix it
                
+
                Remove the @dataclass decorator from the Enum class. Enums work perfectly fine without it and have their own mechanisms for defining
+members.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from dataclasses import dataclass
+from enum import Enum
+
+@dataclass  # Noncompliant
+class Status(Enum):
+    PENDING = 1
+    APPROVED = 2
+    REJECTED = 3
+
                
+
                Compliant solution
                
+
                +from enum import Enum
+
+class Status(Enum):
+    PENDING = 1
+    APPROVED = 2
+    REJECTED = 3
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8490.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8490.json
new file mode 100644
index 0000000000..efde2bc5a6
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8490.json
@@ -0,0 +1,24 @@
+{
+  "title": "Enum classes should not be decorated with \"@dataclass\"",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pitfall",
+    "enum"
+  ],
+  "defaultSeverity": "Blocker",
+  "ruleSpecification": "RSPEC-8490",
+  "sqKey": "S8490",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "BLOCKER"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8492.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8492.html
new file mode 100644
index 0000000000..d87c255df4
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8492.html
@@ -0,0 +1,48 @@
+
                This rule raises an issue when code checks if an element exists in a set using the in operator before calling remove() on
+that element.
                
+
                Why is this an issue?
                
+
                Checking whether an element exists in a set before removing it is unnecessary:
                
+
                +if x in my_set:
+    my_set.remove(x)
+
                
+
                This pattern has two problems:
                
+
                  
+  
                1. double lookup: the code performs two hash table lookups - one for the membership check (in) and another for the
+  removal (remove()). Each lookup has a cost.
                  2. 
+  
                2. less idiomatic: Python provides the discard() method specifically for this use case. Using it makes the code more
+  Pythonic and signals intent more clearly.
                  3. 
+
                
+
                The discard() method combines both operations into a single call. It removes the element if it exists and does nothing otherwise:
                
+
                +my_set.discard(x)  # Single lookup, no exception if x is not present
+
                
+
                What is the potential impact?
                
+
                Using discard() improves readability and removes a redundant hash table lookup. In loops or performance-critical code, eliminating
+these extra lookups can provide measurable improvements.
                
+
                How to fix it
                
+
                Replace the conditional check and remove() call with a single discard() call. The discard() method safely
+removes the element if it exists and does nothing if it does not, without raising an exception.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +my_set = {1, 2, 3, 4, 5}
+value = 3
+
+if value in my_set:  # Noncompliant
+    my_set.remove(value)
+
                
+
                Compliant solution
                
+
                +my_set = {1, 2, 3, 4, 5}
+value = 3
+
+my_set.discard(value)
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8492.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8492.json
new file mode 100644
index 0000000000..1dc60286fc
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8492.json
@@ -0,0 +1,25 @@
+{
+  "title": "\"set.discard()\" should be used instead of checking membership before removal",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "2 min"
+  },
+  "tags": [
+    "performance",
+    "pythonic",
+    "idiom"
+  ],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-8492",
+  "sqKey": "S8492",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8493.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8493.html
new file mode 100644
index 0000000000..d92d437f13
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8493.html
@@ -0,0 +1,52 @@
+
                This rule raises an issue when StopIteration is explicitly raised within a generator function, that is, a function containing
+yield.
                
+
                Why is this an issue?
                
+
                In Python, generators are special functions that use the yield keyword to produce a sequence of values lazily. They implement the
+iterator protocol and are used to create iterators in a concise way.
                
+
                Traditionally, raising StopIteration was the standard way to signal that an iterator had no more values to produce. However, this
+could lead to subtle bugs when StopIteration exceptions from nested iterators or function calls accidentally propagated up and terminated
+the generator unexpectedly.
                
+
                To address this issue, PEP 479 changed the behavior in Python 3.7+. Now, when
+StopIteration is raised inside a generator function, Python automatically converts it to a RuntimeError. This conversion
+happens at the point where the exception would leave the generator.
                
+
                This means code that explicitly raises StopIteration in a generator will fail with a RuntimeError at runtime in Python
+3.7 and later versions. The error message will indicate that the StopIteration exception was raised inside a generator.
                
+
                The proper way to terminate a generator is to use a return statement, optionally with a value. When a generator executes a
+return, Python automatically raises StopIteration behind the scenes, but does so in a way that is compatible with PEP
+479.
                
+
                What is the potential impact?
                
+
                When StopIteration is raised inside a generator in Python 3.7+, it causes a RuntimeError at runtime. This can lead
+to:
                
+
                  
+  
                • application crashes or unexpected failures
                  • 
+  
                • difficult-to-debug errors, especially in production environments
                  • 
+  
                • code that works in older Python versions but breaks when upgraded
                  • 
+  
                • inconsistent behavior across different Python versions
                  • 
+
                
+
                How to fix it
                
+
                Replace the raise StopIteration statement with a return statement. In generators, return is the proper way
+to signal completion. If you need to return a value when the generator completes, you can use return value, though note that this value
+is not yielded but becomes the exception value of the StopIteration that is automatically raised.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +def my_generator():
+    yield 1
+    yield 2
+    raise StopIteration  # Noncompliant
+
                
+
                Compliant solution
                
+
                +def my_generator():
+    yield 1
+    yield 2
+    return  # Properly terminates the generator
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8493.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8493.json
new file mode 100644
index 0000000000..bb764c394e
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8493.json
@@ -0,0 +1,25 @@
+{
+  "title": "\"StopIteration\" should not be raised inside generators",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pitfall",
+    "python3"
+  ],
+  "defaultSeverity": "Blocker",
+  "ruleSpecification": "RSPEC-8493",
+  "sqKey": "S8493",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "BLOCKER",
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8494.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8494.html
new file mode 100644
index 0000000000..feaf967e56
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8494.html
@@ -0,0 +1,57 @@
+
                This rule raises an issue when code assigns a value to an attribute that is not listed in the class’s __slots__ declaration.
                
+
                Why is this an issue?
                
+
                In Python, the __slots__ class attribute is used to explicitly declare which instance attributes a class can have. When a class
+defines __slots__, Python restricts instances to only those attributes, preventing the creation of new attributes dynamically.
                
+
                This restriction serves several purposes:
                
+
                  
+  
                • memory efficiency: instances use less memory because Python does not create a __dict__ for each instance
                  • 
+  
                • faster attribute access: attribute lookups are faster with __slots__
                  • 
+  
                • explicit interface: the class clearly declares which attributes it supports
                  • 
+
                
+
                Assigning to an attribute that is not in __slots__ causes Python to raise an AttributeError at runtime:
                
+
                +class Point:
+    __slots__ = ['x', 'y']
+
+p = Point()
+p.x = 10  # OK
+p.z = 20  # Raises AttributeError: 'Point' object has no attribute 'z'
+
                
+
                What is the potential impact?
                
+
                When code attempts to assign to an attribute not in __slots__, the application will crash with an AttributeError at
+runtime. This can lead to:
                
+
                  
+  
                • application crashes: the error will terminate the current operation unless properly handled
                  • 
+  
                • data loss: if the assignment happens during a data processing operation, partial results may be lost
                  • 
+  
                • poor user experience: users may encounter unexpected errors during normal operations
                  • 
+  
                • difficult debugging: the error may only occur in specific scenarios, making it hard to reproduce and fix
                  • 
+
                
+
                How to fix it
                
+
                If the attribute should be part of the class’s interface, add it to the __slots__ declaration.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +class User:
+    __slots__ = ['name', 'email']
+
+    def __init__(self, name, email, age):
+        self.name = name
+        self.email = email
+        self.age = age  # Noncompliant: "age" is not in __slots__
+
                
+
                Compliant solution
                
+
                +class User:
+    __slots__ = ['name', 'email', 'age']
+
+    def __init__(self, name, email, age):
+        self.name = name
+        self.email = email
+        self.age = age
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8494.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8494.json
new file mode 100644
index 0000000000..d59eda7e67
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8494.json
@@ -0,0 +1,24 @@
+{
+  "title": "Attributes should only be assigned if they are declared in \"__slots__\"",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pitfall",
+    "slots"
+  ],
+  "defaultSeverity": "Blocker",
+  "ruleSpecification": "RSPEC-8494",
+  "sqKey": "S8494",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "BLOCKER"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8495.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8495.html
new file mode 100644
index 0000000000..24cca90efc
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8495.html
@@ -0,0 +1,69 @@
+
                This rule raises an issue when a function returns tuples of different lengths in different code paths.
                
+
                Why is this an issue?
                
+
                When a function returns tuples of varying lengths, it creates an inconsistent API that is difficult to use correctly. Callers cannot reliably
+unpack the return value without checking its length first, which leads to fragile code.
                
+
                Consider this example:
                
+
                +def process_data(value):
+    if value > 0:
+        return (value,)  # Returns a 1-tuple
+    else:
+        return (value, value * 2)  # Returns a 2-tuple
+
+# Caller has no reliable way to unpack this
+result = process_data(10)
+x, y = result  # ValueError if value > 0!
+
                
+
                This forces callers to add defensive length-checks before unpacking, making the code fragile and harder to maintain. The function signature
+provides no indication that the return type varies, so developers must read the implementation or discover the behavior through runtime errors.
                
+
                Consistent return types make code more predictable, easier to test, and less likely to cause unexpected failures in production.
                
+
                What is the potential impact?
                
+
                Runtime errors from tuple unpacking may not surface during initial testing if certain code paths are not fully exercised, leading to production
+failures. The need for defensive length-checking also increases the maintenance burden and makes the API harder to document for new team members.
                
+
                How to fix it
                
+
                Make all return statements return tuples of the same length. Add placeholder values (like None or 0) to shorter tuples to
+maintain consistency.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +def calculate_stats(numbers):
+    if not numbers:
+        return (0,)  # Noncompliant
+    total = sum(numbers)
+    average = total / len(numbers)
+    return (total, average)
+
                
+
                Compliant solution
                
+
                +def calculate_stats(numbers):
+    if not numbers:
+        return (0, 0)  # Consistent 2-tuple
+    total = sum(numbers)
+    average = total / len(numbers)
+    return (total, average)
+
                
+
                Going the extra mile
                
+
                For complex return types, consider using typing.NamedTuple to make the return value self-documenting. Named tuples provide clear field
+names and enforce a consistent structure, making the API easier to use and understand.
                
+
                +from typing import NamedTuple
+
+class Stats(NamedTuple):
+    total: float
+    average: float
+
+def calculate_stats(numbers) -> Stats:
+    if not numbers:
+        return Stats(total=0, average=0)
+    total = sum(numbers)
+    average = total / len(numbers)
+    return Stats(total=total, average=average)
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8495.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8495.json
new file mode 100644
index 0000000000..200899a217
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8495.json
@@ -0,0 +1,26 @@
+{
+  "title": "Functions should return tuples of consistent length",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "10 min"
+  },
+  "tags": [
+    "pitfall",
+    "api-design",
+    "type-system"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8495",
+  "sqKey": "S8495",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH",
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8500.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8500.html
new file mode 100644
index 0000000000..daa6f5f858
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8500.html
@@ -0,0 +1,106 @@
+
                This rule raises an issue when a class defines one or more rich comparison methods (__lt__, __le__, __gt__,
+__ge__) without using the functools.total_ordering decorator or defining all of them.
                
+
                Why is this an issue?
                
+
                Python classes can implement rich comparison methods to enable sorting and comparison operations. These methods include:
                
+
                  
+  
                • __lt__ for less than (<)
                  • 
+  
                • __le__ for less than or equal to (<=)
                  • 
+  
                • __gt__ for greater than (>)
                  • 
+  
                • __ge__ for greater than or equal to (>=)
                  • 
+  
                • __eq__ for equality (==)
                  • 
+  
                • __ne__ for inequality (!=)
                  • 
+
                
+
                When you define only some of these methods, Python cannot automatically infer the missing ones. This leads to inconsistent behavior:
                
+
                  
+  
                • sorting algorithms may fail or produce incorrect results
                  • 
+  
                • comparison operations may raise TypeError exceptions
                  • 
+  
                • code that expects symmetric comparisons, such as a < b being true implying b > a is also true, may behave
+  unexpectedly
                  • 
+
                
+
                Python provides the functools.total_ordering decorator specifically to solve this problem. It allows you to define just
+__eq__ and one other comparison method, and it automatically generates the rest. This ensures consistent and correct comparison behavior
+across all operations.
                
+
                What is the potential impact?
                
+
                Incomplete comparison method implementations can cause several problems:
                
+
                  
+  
                • Sorting failures: built-in functions like sorted() or list methods like sort() may raise exceptions
+  or produce incorrect ordering
                  • 
+  
                • Unexpected comparison results: code that relies on comparison symmetry may produce wrong results, leading to logic errors
                  • 
+  
                • Maintenance difficulties: future developers may not realize that certain comparison operations are missing, leading to bugs
+  when they use those operations
                  • 
+  
                • Container behavior: data structures like heaps or priority queues that depend on comparisons may malfunction
                  • 
+
                
+
                While this typically will not cause security vulnerabilities, it can lead to application logic errors that are difficult to diagnose and debug.
                
+
                How to fix it
                
+
                Either use the @functools.total_ordering decorator and define __eq__ and one ordering method, typically
+__lt__, or define all four ordering methods (__lt__, __le__, __gt__, __ge__)
+explicitly.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    def __lt__(self, other):  # Noncompliant
+        return self.age < other.age
+
                
+
                Compliant solution
                
+
                +from functools import total_ordering
+
+@total_ordering
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    def __eq__(self, other):
+        return self.age == other.age
+
+    def __lt__(self, other):
+        return self.age < other.age
+
                
+
                Noncompliant code example
                
+
                +class Point:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def __lt__(self, other):  # Noncompliant
+        return self.x < other.x
+
                
+
                Compliant solution
                
+
                +class Point:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def __lt__(self, other):
+        return self.x < other.x
+
+    def __le__(self, other):
+        return self.x <= other.x
+
+    def __gt__(self, other):
+        return self.x > other.x
+
+    def __ge__(self, other):
+        return self.x >= other.x
+
                
+
                How does this work?
                
+
                The @functools.total_ordering decorator automatically generates all missing comparison methods from the ones you define. This ensures
+consistent and correct comparison behavior across all operations.
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8500.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8500.json
new file mode 100644
index 0000000000..8f10a3067a
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8500.json
@@ -0,0 +1,25 @@
+{
+  "title": "Comparison methods should be defined completely",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pitfall",
+    "comparison"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8500",
+  "sqKey": "S8500",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH",
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "COMPLETE"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8502.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8502.html
new file mode 100644
index 0000000000..a0f000b256
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8502.html
@@ -0,0 +1,40 @@
+
                This rule raises an issue when a for-loop is used to add all elements from one collection to a set using the add() method.
                
+
                Why is this an issue?
                
+
                Adding elements to a set one at a time in a loop is unnecessary when the update() method exists:
                
+
                +for element in other_collection:
+    my_set.add(element)
+
                
+
                The update() method combines all additions into a single call and avoids the overhead of repeated add() invocations:
                
+
                +my_set.update(other_collection)  # Single call, more efficient
+
                
+
                What is the potential impact?
                
+
                Using update() improves readability and removes redundant method call overhead. In loops or performance-critical code, the difference
+can become measurable.
                
+
                How to fix it
                
+
                Replace the for-loop with a single update() call. The method accepts any iterable.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +my_set = {1, 2, 3}
+other_collection = [4, 5, 6]
+
+for element in other_collection:
+    my_set.add(element)  # Noncompliant
+
                
+
                Compliant solution
                
+
                +my_set = {1, 2, 3}
+other_collection = [4, 5, 6]
+
+my_set.update(other_collection)
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8502.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8502.json
new file mode 100644
index 0000000000..4884171784
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8502.json
@@ -0,0 +1,25 @@
+{
+  "title": "\"set.update()\" should be used instead of a for-loop with \"add()\"",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "2 min"
+  },
+  "tags": [
+    "pythonic",
+    "performance",
+    "idiom"
+  ],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-8502",
+  "sqKey": "S8502",
+  "scope": "All",
+  "quickfix": "partial",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "EFFICIENT"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8503.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8503.html
new file mode 100644
index 0000000000..234a3d02cf
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8503.html
@@ -0,0 +1,65 @@
+
                This rule raises an issue when a membership test using in or not in is performed on an empty collection literal such as
+[], {}, set(), tuple(), or frozenset().
                
+
                Why is this an issue?
                
+
                In Python, the membership operators in and not in test whether a value exists in a collection. When the collection is
+empty, these tests always produce predictable results:
                
+
                  
+  
                • x in [] is always False because the value cannot exist in an empty collection
                  • 
+  
                • x not in [] is always True because the value is indeed not in an empty collection
                  • 
+
                
+
                This pattern typically indicates one of three problems:
                
+
                  
+  
                • dead code: the check serves no purpose and should be removed
                  • 
+  
                • logic error: the collection should have been populated before the membership test
                  • 
+  
                • incomplete implementation: the code was started but never finished
                  • 
+
                
+
                Consider this example:
                
+
                +if user_id in []:
+    grant_access()
+
                
+
                This condition will never be true, so grant_access() will never be called. The code is either incomplete, meaning the list should
+contain authorized user IDs, or the check is unnecessary and should be removed.
                
+
                The issue applies to all Python collection types:
                
+
                  
+  
                • empty list: []
                  • 
+  
                • empty dict: {}, which creates an empty dictionary, not a set. When used with in, it tests keys.
                  • 
+  
                • empty set: set()
                  • 
+  
                • empty tuple: () or tuple()
                  • 
+  
                • empty frozenset: frozenset()
                  • 
+
                
+
                What is the potential impact?
                
+
                This issue can lead to bugs where conditions never evaluate as expected, causing:
                
+
                  
+  
                • dead code paths: code that can never be reached
                  • 
+  
                • security vulnerabilities: authorization checks that never pass or always pass
                  • 
+  
                • logic errors: incorrect program behavior due to conditions that do not work as intended
                  • 
+
                
+
                The severity depends on the context. An authorization check that always fails could be a critical security issue, while a redundant check might
+only affect code maintainability.
                
+
                How to fix it
                
+
                If the collection should contain values, populate it with the appropriate elements before performing the membership test.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +if user_id in []:  # Noncompliant: empty list
+    grant_access()
+
                
+
                Compliant solution
                
+
                +if user_id in ["admin", "user123", "moderator"]:
+    grant_access()
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S2583} - Conditionals should not always evaluate to the same value
                  • 
+  
                • {rule:python:S1145} - Useless "if(true) {…​}" and "if(false){…​}" blocks should be removed
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8503.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8503.json
new file mode 100644
index 0000000000..70e7f641c4
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8503.json
@@ -0,0 +1,25 @@
+{
+  "title": "Membership tests should not use empty collections",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pitfall",
+    "suspicious"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8503",
+  "sqKey": "S8503",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8504.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8504.html
new file mode 100644
index 0000000000..9c297522e4
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8504.html
@@ -0,0 +1,45 @@
+
                This rule raises an issue when a method decorated with @property does not contain any return statement.
                
+
                Why is this an issue?
                
+
                In Python, the @property decorator transforms a method into a getter for a computed attribute. When you access a property, you expect
+to receive a value, just like accessing a regular attribute.
                
+
                A property method without a return statement will implicitly return None. This makes the property useless because it
+always provides None instead of a meaningful value. This behavior is almost always unintentional and indicates a bug in the code.
                
+
                Exceptions
                
+
                This rule does not raise an issue when the property method raises an exception or is decorated with @abstractmethod, as these are
+intentional patterns where a return value is not expected.
                
+
                What is the potential impact?
                
+
                When a property method lacks a return statement, it always returns None. This leads to:
                
+
                  
+  
                • logic errors: code that depends on the property value will behave incorrectly, potentially causing application failures or
+  incorrect results.
                  • 
+  
                • difficult debugging: the implicit None return is not obvious from looking at the property access, making bugs
+  harder to trace.
                  • 
+  
                • API contract violation: users of the class expect the property to provide meaningful data, but receive None
+  instead, breaking the expected interface.
                  • 
+
                
+
                How to fix it
                
+
                Add a return statement to the property method that returns the intended value.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +@property
+def area(self):
+    3.14159 * self._radius ** 2  # Noncompliant
+
                
+
                Compliant solution
                
+
                +@property
+def area(self):
+    return 3.14159 * self._radius ** 2
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S3801} - Functions should use "return" consistently
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8504.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8504.json
new file mode 100644
index 0000000000..41dda19246
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8504.json
@@ -0,0 +1,23 @@
+{
+  "title": "Property methods should have a return statement",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pitfall"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8504",
+  "sqKey": "S8504",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8505.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8505.html
new file mode 100644
index 0000000000..c66bcb49cb
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8505.html
@@ -0,0 +1,169 @@
+
                This rule raises an issue when @singledispatch is used on a method defined inside a class instead of
+@singledispatchmethod, or when @singledispatchmethod is used on a standalone function instead of
+@singledispatch. It also flags problematic combinations with @classmethod and @staticmethod.
                
+
                Why is this an issue?
                
+
                The @singledispatch and @singledispatchmethod decorators from functools serve different purposes and are not
+interchangeable.
                
+
                @singledispatch is designed for standalone functions. It dispatches based on the type of the first positional argument. When applied
+to an instance method, the first argument is self, so dispatch is performed on the type of the instance instead of on the actual data
+argument. The registered type implementations (for example, for int or str) are therefore never selected based on the
+data:
                
+
                  
+  
                • In the typical case, every call falls through to the base implementation regardless of the data argument’s type, because the receiver class is
+  not registered as a dispatch type.
                  • 
+  
                • In the rarer case where the receiver class (or one of its ancestors in the MRO) happens to match a registered type, dispatch may resolve to a
+  different registered implementation depending on the receiver, so the same call site can produce different results in different
+  parts of a class hierarchy.
                  • 
+
                
+
                @singledispatchmethod is designed for instance methods and class methods. It returns a non-callable descriptor that relies on the
+descriptor protocol to bind to an instance or class. When applied to a standalone function, the resulting object cannot be invoked at all, and calling
+it raises a TypeError.
                
+
                This rule also flags @singledispatch applied to a method decorated with @classmethod. In that case, the dispatcher
+attempts to operate on a classmethod object rather than a plain function, and the call fails at runtime.
                
+
                In all of these cases, no error or warning is raised at decoration time, and some failure modes only surface on the first call, making the bug
+silent and hard to detect by reading the code alone.
                
+
                Exceptions
                
+
                The rule’s behavior with @staticmethod depends on the decorator order:
                
+
                  
+  
                • @singledispatch placed above @staticmethod is flagged. In that order,
+  @singledispatch wraps the staticmethod descriptor object, which makes both registration of overloads and dispatch on
+  instances unreliable.
                  • 
+  
                • @staticmethod placed above @singledispatch is not flagged, because
+  @singledispatch is then applied to a regular function and @staticmethod simply prevents Python from binding
+  self, so dispatch correctly happens on the data argument.
                  • 
+
                
+
                Note that even the non-flagged order is uncommon and easy to misuse: a future refactor that swaps the order silently reintroduces the bug.
                
+
                What is the potential impact?
                
+
                Confusing these two decorators causes the type dispatch mechanism to behave incorrectly:
                
+
                  
+  
                • registered type implementations will not be called for the expected argument
                  • 
+  
                • with @singledispatch on an instance method, calls on subclasses may resolve to different registered
+  implementations than calls on the base class, so the same call site can produce different results depending on the receiver’s type
                  • 
+  
                • the code may appear to work in simple tests but fail or behave inconsistently in production with different input types or in larger class
+  hierarchies
                  • 
+  
                • debugging is difficult because no error or warning is raised at decoration time, and broken combinations such as @singledispatch
+  with @classmethod or above @staticmethod typically fail only at call time
                  • 
+
                
+
                How to fix it
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                Using @singledispatch on a class method:
                
+
                +from functools import singledispatch
+
+class Processor:
+    @singledispatch  # Noncompliant: should use @singledispatchmethod for methods
+    def process(self, data):
+        return f"Processing: {data}"
+
+    @process.register(int)
+    def _(self, data):
+        return f"Processing int: {data}"
+
+    @process.register(str)
+    def _(self, data):
+        return f"Processing str: {data}"
+
                
+
                Compliant solution
                
+
                +from functools import singledispatchmethod
+
+class Processor:
+    @singledispatchmethod
+    def process(self, data):
+        return f"Processing: {data}"
+
+    @process.register(int)
+    def _(self, data):
+        return f"Processing int: {data}"
+
+    @process.register(str)
+    def _(self, data):
+        return f"Processing str: {data}"
+
                
+
                Noncompliant code example
                
+
                Using @singledispatchmethod on a standalone function:
                
+
                +from functools import singledispatchmethod
+
+@singledispatchmethod  # Noncompliant: should use @singledispatch for standalone functions
+def process(data):
+    return f"Processing: {data}"
+
+@process.register(int)
+def _(data):
+    return f"Processing int: {data}"
+
+@process.register(str)
+def _(data):
+    return f"Processing str: {data}"
+
                
+
                Compliant solution
                
+
                +from functools import singledispatch
+
+@singledispatch
+def process(data):
+    return f"Processing: {data}"
+
+@process.register(int)
+def _(data):
+    return f"Processing int: {data}"
+
+@process.register(str)
+def _(data):
+    return f"Processing str: {data}"
+
                
+
                Noncompliant code example
                
+
                Using @singledispatch on a @classmethod:
                
+
                +from functools import singledispatch
+
+class Processor:
+    @singledispatch  # Noncompliant: @singledispatch wraps a classmethod descriptor
+    @classmethod
+    def process(cls, data):
+        return f"Processing: {data}"
+
+    @process.register(int)
+    @classmethod
+    def _(cls, data):
+        return f"Processing int: {data}"
+
                
+
                Compliant solution
                
+
                +from functools import singledispatchmethod
+
+class Processor:
+    @singledispatchmethod
+    @classmethod
+    def process(cls, data):
+        return f"Processing: {data}"
+
+    @process.register
+    @classmethod
+    def _(cls, data: int):
+        return f"Processing int: {data}"
+
                
+
                How does this work?
                
+
                Use @singledispatch for standalone, module-level functions and @singledispatchmethod for instance methods and class
+methods. The @singledispatch decorator dispatches on the first argument, while @singledispatchmethod skips self
+or cls and dispatches on the next argument.
                
+
                When combining @singledispatchmethod with @classmethod, @singledispatchmethod must remain the outermost
+decorator so that the registration mechanism (process.register) is still available. @classmethod is then applied to the base
+implementation and to each registered overload.
                
+
                For static methods, prefer turning the function into a module-level function decorated with @singledispatch. If the dispatcher must
+live on the class, place @staticmethod above @singledispatch so that @singledispatch wraps a
+regular function rather than a staticmethod descriptor; the inverse order is reported by this rule. More generally, prefer
+@singledispatch on a module-level function whenever the dispatcher does not need to live on a class, since stacked-decorator orders are
+easy to misuse and silently regress on refactors.
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8505.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8505.json
new file mode 100644
index 0000000000..98a5ee0761
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8505.json
@@ -0,0 +1,25 @@
+{
+  "title": "\"@singledispatch\" and \"@singledispatchmethod\" should not be confused",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pitfall",
+    "confusing"
+  ],
+  "defaultSeverity": "Blocker",
+  "ruleSpecification": "RSPEC-8505",
+  "sqKey": "S8505",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "BLOCKER",
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8507.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8507.html
new file mode 100644
index 0000000000..86bf4e4412
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8507.html
@@ -0,0 +1,41 @@
+
                This rule raises an issue when a TypeVar, ParamSpec, or NewType is assigned to a variable whose name does
+not match the string name passed to its constructor.
                
+
                Why is this an issue?
                
+
                In Python’s typing system, TypeVar, ParamSpec, and NewType are special constructs used to define generic
+types and type aliases. When creating these objects, you provide a string name as the first argument to the constructor. The convention is that this
+string name should match the variable name to which the type is assigned.
                
+
                When the names do not match, type checkers and runtime error messages use the string name from the constructor, which can make error messages
+confusing. IDEs and other development tools may also rely on this naming convention to provide accurate type information.
                
+
                What is the potential impact?
                
+
                Mismatched names create confusion for developers reading the code and make error messages harder to understand. This can slow down debugging and
+make code reviews more difficult, reducing overall development efficiency.
                
+
                In larger codebases with multiple type variables, mismatched names can lead to mistakes when refactoring or extending generic classes and
+functions.
                
+
                How to fix it
                
+
                Ensure the string name passed to the constructor matches the variable name it is assigned to.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from typing import TypeVar, ParamSpec, NewType
+
+MyType = TypeVar("T")  # Noncompliant: variable is "MyType" but string is "T"
+MyParams = ParamSpec("P")  # Noncompliant: variable is "MyParams" but string is "P"
+MyInt = NewType("Integer", int)  # Noncompliant: variable is "MyInt" but string is "Integer"
+
                
+
                Compliant solution
                
+
                +from typing import TypeVar, ParamSpec, NewType
+
+MyType = TypeVar("MyType")  # Compliant: names match
+MyParams = ParamSpec("MyParams")  # Compliant: names match
+MyInt = NewType("MyInt", int)  # Compliant: names match
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8507.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8507.json
new file mode 100644
index 0000000000..5ba073ad03
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8507.json
@@ -0,0 +1,25 @@
+{
+  "title": "TypeVar, ParamSpec, and NewType names should match their assigned variable names",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "convention",
+    "type-hint",
+    "readability"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8507",
+  "sqKey": "S8507",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8508.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8508.html
new file mode 100644
index 0000000000..e634ff9288
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8508.html
@@ -0,0 +1,89 @@
+
                This rule raises an issue when a mutable object is used as the default value in dict.fromkeys() or
+contextvars.ContextVar().
                
+
                Why is this an issue?
                
+
                In Python, when you pass a mutable object as a default value to certain constructs, all instances share the same object reference rather than
+getting independent copies. This creates unintended shared state that leads to subtle mutation bugs.
                
+
                Python evaluates the default value expression once when the code is defined, not each time it is used. The same object instance is then reused
+across all keys or contexts. This is different from creating new instances for each use.
                
+
                This issue is related to, but distinct from, the more commonly known problem of mutable default arguments in function definitions (e.g., def
+func(items=[])), which has the same underlying cause.
                
+
                The problem with dict.fromkeys()
                
+
                The dict.fromkeys(keys, value) method creates a dictionary with all specified keys pointing to the same
+value object. When this value is mutable (like a list or dictionary), all keys share the same object reference:
                
+
                +keys = ['a', 'b', 'c']
+my_dict = dict.fromkeys(keys, [])
+my_dict['a'].append(1)
+print(my_dict)  # {'a': [1], 'b': [1], 'c': [1]}
+
                
+
                Modifying the list through one key affects all other keys because they all reference the same list object in memory.
                
+
                The problem with ContextVar()
                
+
                Similarly, when you create a ContextVar with a mutable default value, that same object is shared across all contexts:
                
+
                +from contextvars import ContextVar
+
+my_var = ContextVar('my_var', default=[])
+my_var.get().append(1)  # Modifies the shared default
+
                
+
                This is particularly problematic in concurrent code where different contexts should have independent state.
                
+
                What is the potential impact?
                
+
                Using mutable default values in these contexts can cause serious bugs:
                
+
                  
+  
                • data corruption: changes intended for one key or context accidentally affect others, leading to incorrect application
+  state
                  • 
+  
                • difficult debugging: the bug manifests indirectly, making it hard to trace the source of unexpected mutations
                  • 
+  
                • concurrency issues: in the case of ContextVar, shared mutable defaults can cause race conditions and data
+  corruption in concurrent code
                  • 
+  
                • test flakiness: tests may pass or fail inconsistently depending on execution order when shared state accumulates mutations
                  • 
+
                
+
                How to fix it
                
+
                For dict.fromkeys(), replace it with a dictionary comprehension that creates a new instance of the mutable object for each key. For
+ContextVar(), use a factory pattern or set the default in context initialization rather than passing a mutable default directly.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +keys = ['a', 'b', 'c']
+my_dict = dict.fromkeys(keys, [])  # Noncompliant
+
                
+
                Compliant solution
                
+
                +keys = ['a', 'b', 'c']
+my_dict = {key: [] for key in keys}
+
                
+
                Noncompliant code example
                
+
                +from contextvars import ContextVar
+
+my_var = ContextVar('my_var', default=[])  # Noncompliant
+
                
+
                Compliant solution
                
+
                +from contextvars import ContextVar
+
+my_var: ContextVar[list] = ContextVar('my_var')
+
+def get_my_var() -> list:
+    try:
+        return my_var.get()
+    except LookupError:
+        value: list = []
+        my_var.set(value)
+        return value
+
                
+
                Resources
                
+
                Documentation
                
+
+
                External coding guidelines
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S2824} - Function parameters should not have mutable default values
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8508.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8508.json
new file mode 100644
index 0000000000..224719a2b5
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8508.json
@@ -0,0 +1,25 @@
+{
+  "title": "Mutable default values should not be used with \"dict.fromkeys()\" or \"ContextVar()\"",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pitfall",
+    "concurrency"
+  ],
+  "defaultSeverity": "Blocker",
+  "ruleSpecification": "RSPEC-8508",
+  "sqKey": "S8508",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "BLOCKER",
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8509.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8509.html
new file mode 100644
index 0000000000..a2c352e35e
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8509.html
@@ -0,0 +1,43 @@
+
                This rule raises an issue when the same class appears more than once in the inheritance list of a class definition.
                
+
                Why is this an issue?
                
+
                In Python, a class definition can inherit from one or more base classes. The syntax for this is straightforward:
                
+
                +class MyClass(BaseClass1, BaseClass2):
+    pass
+
                
+
                When the same base class appears multiple times in the inheritance list, it serves no purpose and is always a programming error. Python’s Method
+Resolution Order (MRO) ensures that each class appears only once in the inheritance chain, even if it is listed multiple times.
                
+
                This typically happens due to:
                
+
                  
+  
                • copy-paste errors when defining the class
                  • 
+  
                • misunderstanding of how inheritance works
                  • 
+  
                • refactoring mistakes where duplicate entries were not cleaned up
                  • 
+
                
+
                What is the potential impact?
                
+
                This issue has minimal runtime impact since Python automatically removes duplicate base classes from the Method Resolution Order. However, it
+affects code quality:
                
+
                  
+  
                • Maintainability: The duplicate entries make the code confusing and harder to understand
                  • 
+  
                • Code clarity: It suggests the code has not been properly reviewed
                  • 
+  
                • Future errors: It may indicate a misunderstanding of inheritance that could lead to more serious bugs
                  • 
+
                
+
                How to fix it
                
+
                Remove the duplicate base class from the inheritance list, keeping only one occurrence.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +class MyWidget(QWidget, Serializable, QWidget):  # Noncompliant
+    pass
+
                
+
                Compliant solution
                
+
                +class MyWidget(QWidget, Serializable):
+    pass
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8509.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8509.json
new file mode 100644
index 0000000000..f50c34ecdd
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8509.json
@@ -0,0 +1,24 @@
+{
+  "title": "Classes should not inherit from the same base class multiple times",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pitfall",
+    "confusing"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8509",
+  "sqKey": "S8509",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8510.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8510.html
new file mode 100644
index 0000000000..3c0ea9cee0
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8510.html
@@ -0,0 +1,63 @@
+
                This rule raises an issue when a nested loop uses the same variable name as an outer loop, causing the inner loop to shadow the outer loop
+variable.
                
+
                Why is this an issue?
                
+
                In Python, loop variables persist after the loop completes and can be reassigned by inner loops without any warning. Unlike languages with
+block-scoped variables, Python allows inner loops to silently overwrite outer loop variables, making the outer variable inaccessible within the inner
+loop scope.
                
+
                This happens because Python’s for loop assigns the loop variable in the current scope, regardless of whether a variable with that name
+already exists. When you write:
                
+
                +for i in range(10):
+    for i in range(5):
+        pass
+
                
+
                The inner loop reassigns i on each iteration, completely replacing the value from the outer loop. After the inner loop completes,
+i contains the last value from the inner loop (4), not the current value from the outer loop.
                
+
                This pattern almost always indicates a programmer error rather than intentional behavior. Common scenarios include:
                
+
                  
+  
                • copying loop patterns without changing variable names
                  • 
+  
                • iterating over an object’s properties using the object’s own name
                  • 
+  
                • confusion about Python’s scoping rules
                  • 
+
                
+
                The shadowing happens silently without any compiler or runtime warning, making these bugs difficult to spot during code review and testing.
                
+
                What is the potential impact?
                
+
                Using the same variable in nested loops leads to logic errors that can be difficult to debug:
                
+
                  
+  
                • Incorrect iteration behavior: any code after the inner loop but within the outer loop body will see the wrong value of the loop
+  variable.
                  • 
+  
                • Unexpected variable values: after the inner loop completes, the variable contains the last value from the inner loop instead of
+  the expected outer loop value.
                  • 
+  
                • Silent failures: the code may appear to work in simple test cases but fail in production with different data.
                  • 
+  
                • Maintenance issues: future modifications may rely on the outer loop variable, causing new bugs when it contains unexpected
+  values.
                  • 
+
                
+
                How to fix it
                
+
                Use different variable names for each loop. Choose descriptive names that reflect what each variable represents.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +for i in range(10):
+    print(f"Outer: {i}")
+    for i in range(5):  # Noncompliant
+        print(f"Inner: {i}")
+    # i now contains 4, not the outer loop value
+
                
+
                Compliant solution
                
+
                +for i in range(10):
+    print(f"Outer: {i}")
+    for j in range(5):
+        print(f"Inner: {j}")
+    # i still contains the outer loop value
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S1117} - Local variables should not shadow other variables
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8510.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8510.json
new file mode 100644
index 0000000000..d84e7479ef
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8510.json
@@ -0,0 +1,25 @@
+{
+  "title": "Loop variables should not be reused in nested loops",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "2min"
+  },
+  "tags": [
+    "confusing",
+    "pitfall"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8510",
+  "sqKey": "S8510",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH",
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8511.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8511.html
new file mode 100644
index 0000000000..d9bec19731
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8511.html
@@ -0,0 +1,59 @@
+
                This rule raises an issue when a class definition with multiple inheritance results in an unresolvable Method Resolution Order (MRO).
                
+
                Why is this an issue?
                
+
                Python uses the C3 linearization algorithm (also called C3 superclass linearization) to determine the Method Resolution Order (MRO) - the order in
+which base classes are searched when looking up methods and attributes. This algorithm ensures a consistent and predictable class hierarchy.
                
+
                When a class is created with multiple inheritance, Python must be able to construct a valid MRO. If the inheritance structure violates the C3
+linearization rules, Python raises a TypeError at class definition time, preventing the class from being created at all.
                
+
                C3 linearization rules
                
+
                The C3 algorithm enforces these key constraints:
                
+
                  
+  
                • Local precedence ordering: If class C inherits from A then B (i.e., class C(A,
+  B)), then A must appear before B in the MRO
                  • 
+  
                • Monotonicity: If class A appears before class B in the MRO of a parent class, then A
+  must also appear before B in the MRO of any child class
                  • 
+
                
+
                Violating these rules creates an inconsistent hierarchy where Python cannot determine which parent class should take precedence.
                
+
                What is the potential impact?
                
+
                MRO inconsistencies cause immediate failures at class definition time — Python raises a TypeError and the class is never created,
+breaking the application at import time.
                
+
                How to fix it
                
+
                To fix MRO inconsistencies, restructure the inheritance hierarchy to respect the C3 linearization rules. Remove redundant base classes from the
+inheritance list, as a class does not need to directly inherit from a grandparent if it is already inherited through a parent.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +class A:
+    pass
+
+class B(A):
+    pass
+
+class C(A):
+    pass
+
+class D(B, A, C):  # Noncompliant: inconsistent MRO for bases A and C; D requires A before C, but C inherits from A
+    pass
+
                
+
                Compliant solution
                
+
                +class A:
+    pass
+
+class B(A):
+    pass
+
+class C(A):
+    pass
+
+class D(B, C):  # Compliant: A is inherited through B and C
+    pass
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8511.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8511.json
new file mode 100644
index 0000000000..df35c3dc78
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8511.json
@@ -0,0 +1,25 @@
+{
+  "title": "Multiple inheritance should not create Method Resolution Order (MRO) conflicts",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "30min"
+  },
+  "tags": [
+    "design",
+    "inheritance",
+    "pitfall"
+  ],
+  "defaultSeverity": "Blocker",
+  "ruleSpecification": "RSPEC-8511",
+  "sqKey": "S8511",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "BLOCKER"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8512.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8512.html
new file mode 100644
index 0000000000..be3988d9c5
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8512.html
@@ -0,0 +1,47 @@
+
                This rule raises an issue when the same class field is unconditionally assigned multiple times within a class body.
                
+
                Why is this an issue?
                
+
                When a class field is defined multiple times in the same class body, only the last assignment takes effect. All previous assignments are dead code
+that serve no purpose.
                
+
                This pattern typically occurs due to:
                
+
                  
+  
                • copy-paste errors: duplicating code blocks without updating field names
                  • 
+  
                • refactoring mistakes: forgetting to remove old assignments when updating values
                  • 
+  
                • merge conflicts: incorrectly resolving version control conflicts
                  • 
+  
                • misunderstanding: confusion about how class attributes work
                  • 
+
                
+
                What is the potential impact?
                
+
                  
+  
                • confusion: developers may not immediately realize which value is actually used
                  • 
+  
                • maintenance burden: dead code must be read, understood, and maintained even though it has no effect
                  • 
+  
                • hidden bugs: the duplicate definition might indicate that two different fields were intended, suggesting a naming error that
+  could lead to incorrect behavior
                  • 
+
                
+
                How to fix it
                
+
                Remove all but the last assignment to the class field. Keep only the final value that should be used.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +class MyClass:
+    x = 1
+    y = 2
+    x = 3  # Noncompliant: "x" is defined twice
+
                
+
                Compliant solution
                
+
                +class MyClass:
+    x = 3
+    y = 2
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S4143} - Collection content should not be replaced unconditionally
                  • 
+  
                • {rule:python:S1534} - Member names should not be duplicated within a class or object literal
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8512.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8512.json
new file mode 100644
index 0000000000..8fc75b77db
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8512.json
@@ -0,0 +1,25 @@
+{
+  "title": "Class fields should not be defined multiple times",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "confusing",
+    "dead-code",
+    "pitfall"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8512",
+  "sqKey": "S8512",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8513.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8513.html
new file mode 100644
index 0000000000..cbf8ab8985
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8513.html
@@ -0,0 +1,53 @@
+
                This rule raises an issue when multiple startswith() or endswith() calls on the same string are chained together using
+the or operator to check for different prefixes or suffixes.
                
+
                Why is this an issue?
                
+
                When you need to check if a string starts or ends with one of several possible values, chaining multiple startswith() or
+endswith() calls with the or operator creates unnecessary verbosity and redundancy. Each additional prefix or suffix
+requires a separate method call and another or operator, making the condition increasingly difficult to read and maintain.
                
+
                This pattern is particularly common when validating file extensions, URL protocols, or any scenario where you need to check for multiple valid
+prefixes or suffixes.
                
+
                What is the potential impact?
                
+
                The consolidated form is easier to read and maintain, reducing the cognitive load on developers reviewing or modifying the code. The performance
+gain from a single consolidated call is modest but accumulates in loops or hot paths.
                
+
                How to fix it
                
+
                Replace multiple startswith() or endswith() calls connected by or operators with a single call that uses a
+tuple containing all the prefixes or suffixes to check.
                
+
                Both startswith() and endswith() methods accept a tuple of strings as their first argument. When you pass a tuple, the
+method checks if the string starts or ends with any of the values in that tuple. This has two main benefits:
                
+
                  
+  
                • readability: the code is more concise and easier to understand at a glance.
                  • 
+  
                • performance: the method is called only once instead of multiple times, reducing overhead.
                  • 
+
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +if s.startswith("http://") or s.startswith("https://"):  # Noncompliant: use a tuple argument instead
+    process_url(s)
+
                
+
                Compliant solution
                
+
                +if s.startswith(("http://", "https://")):
+    process_url(s)
+
                
+
                Noncompliant code example
                
+
                +if filename.endswith(".jpg") or filename.endswith(".png") or filename.endswith(".gif"):  # Noncompliant: use a tuple argument instead
+    display_image(filename)
+
                
+
                Compliant solution
                
+
                +if filename.endswith((".jpg", ".png", ".gif")):
+    display_image(filename)
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S6659} - startswith or endswith methods should be used instead of string slicing in condition
+  expressions
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8513.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8513.json
new file mode 100644
index 0000000000..b952a54e4c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8513.json
@@ -0,0 +1,24 @@
+{
+  "title": "\"startswith\" and \"endswith\" calls should use tuples instead of multiple \"or\" operators",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "performance",
+    "pythonic"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8513",
+  "sqKey": "S8513",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "EFFICIENT"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8514.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8514.html
new file mode 100644
index 0000000000..ce32b2ae5c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8514.html
@@ -0,0 +1,63 @@
+
                This rule raises an issue when a dataclass attribute is assigned a value without a type annotation, suggesting the developer likely intended an
+instance field but silently created a class variable instead.
                
+
                Why is this an issue?
                
+
                The @dataclass decorator only processes attributes that have type annotations. Attributes without annotations are silently excluded
+from dataclass processing and become regular class variables instead of instance attributes. This means:
                
+
                  
+  
                • they are not included in the generated \__init__ method
                  • 
+  
                • they are not part of \__repr__ or \__eq__
                  • 
+  
                • they behave as class variables, not instance variables
                  • 
+
                
+
                What is the potential impact?
                
+
                Unannotated attributes are silently excluded from initialization, \__repr__, and \__eq__, making them invisible to the
+dataclass contract. These bugs are difficult to trace because the class appears to work normally, but the affected attributes do not participate in
+any of the generated methods.
                
+
                How to fix it
                
+
                Add type annotations to all attributes that should be dataclass fields.
                
+
                If you intentionally want a class variable shared across all instances, annotate it with typing.ClassVar[T]. This is the idiomatic
+Python way to declare class variables inside a dataclass. It makes the intent explicit and ensures the attribute is excluded from all generated
+dataclass methods.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from dataclasses import dataclass
+
+@dataclass
+class Config:
+    timeout = 30  # Noncompliant: missing type annotation
+    retries = 3   # Noncompliant: missing type annotation
+
                
+
                Compliant solution
                
+
                +from dataclasses import dataclass
+
+@dataclass
+class Config:
+    timeout: int = 30
+    retries: int = 3
+
                
+
                Noncompliant code example
                
+
                +from dataclasses import dataclass
+
+@dataclass
+class Registry:
+    instance_count = 0  # Noncompliant: intended as a class variable, but not explicit
+
                
+
                Compliant solution
                
+
                +from dataclasses import dataclass
+from typing import ClassVar
+
+@dataclass
+class Registry:
+    instance_count: ClassVar[int] = 0  # Explicit class variable, excluded from __init__
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8514.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8514.json
new file mode 100644
index 0000000000..bcf007808c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8514.json
@@ -0,0 +1,25 @@
+{
+  "title": "Dataclass attributes should use type annotations",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pitfall",
+    "confusing"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8514",
+  "sqKey": "S8514",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8515.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8515.html
new file mode 100644
index 0000000000..a3cb2362eb
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8515.html
@@ -0,0 +1,46 @@
+
                This rule raises an issue when a TypeVar is declared with both covariant=True and contravariant=True.
                
+
                Why is this an issue?
                
+
                A TypeVar in Python represents a type variable used in generic programming. It can have one of three variance modes:
                
+
                  
+  
                • invariant, the default: the type must match exactly
                  • 
+  
                • covariant with covariant=True: the type can be replaced with a subtype
                  • 
+  
                • contravariant with contravariant=True: the type can be replaced with a supertype
                  • 
+
                
+
                These variance modes are mutually exclusive. A type variable cannot be both covariant and contravariant simultaneously because these represent
+opposite relationships in the type hierarchy. Python’s typing module will raise a ValueError at runtime when it encounters
+such a declaration.
                
+
                What is the potential impact?
                
+
                  
+  
                • Python raises a ValueError when the module is imported, causing the application to crash immediately.
                  • 
+  
                • Static type checkers cannot analyze the code properly, reducing confidence in the type safety of the codebase.
                  • 
+
                
+
                How to fix it
                
+
                Choose the appropriate variance mode for your type variable:
                
+
                  
+  
                • if you need covariance to allow subtypes, use only covariant=True
                  • 
+  
                • if you need contravariance to allow supertypes, use only contravariant=True
                  • 
+  
                • if you need exact type matching, omit both parameters for the default invariant behavior
                  • 
+
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from typing import TypeVar
+
+# Invalid: cannot be both covariant and contravariant
+T = TypeVar('T', covariant=True, contravariant=True)  # Noncompliant
+
                
+
                Compliant solution
                
+
                +from typing import TypeVar
+
+# Valid: covariant type variable
+T_co = TypeVar('T_co', covariant=True)
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8515.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8515.json
new file mode 100644
index 0000000000..e952e40675
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8515.json
@@ -0,0 +1,25 @@
+{
+  "title": "TypeVars should not be both covariant and contravariant",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "type",
+    "pitfall"
+  ],
+  "defaultSeverity": "Blocker",
+  "ruleSpecification": "RSPEC-8515",
+  "sqKey": "S8515",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "BLOCKER",
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8516.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8516.html
new file mode 100644
index 0000000000..4cc8fbc709
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8516.html
@@ -0,0 +1,53 @@
+
                This rule raises an issue when a group iterator returned by itertools.groupby() is stored in a container that persists beyond the
+current loop iteration, instead of being consumed immediately.
                
+
                Why is this an issue?
                
+
                The itertools.groupby() function groups consecutive items from an iterable based on a key function. It returns pairs of (key,
+group_iterator) where each group_iterator is a sub-iterator that yields items for that specific group.
                
+
                A critical characteristic of these group iterators is that they share the same underlying data source as the main groupby iterator.
+Every time the outer loop advances to the next group, the previous group iterator is immediately invalidated — regardless of whether it has been
+iterated or not. Storing a raw group iterator and consuming it after the loop has moved on will always yield an empty sequence.
                
+
                What is the potential impact?
                
+
                When group iterators are reused, they yield no items. Your code will process empty sequences instead of the actual grouped data, leading to
+incorrect results, silent failures, and data loss. These issues can be difficult to debug because the code does not raise exceptions but simply
+produces wrong output.
                
+
                How to fix it
                
+
                There are two correct approaches:
                
+
                  
+  
                • Consume the group iterator immediately inside the loop body, never storing the raw iterator at all. This is the simplest
+  pattern and avoids any risk of reuse.
                  • 
+  
                • Materialize the group iterator into a concrete collection (list, tuple, set, etc.)
+  before the loop advances. This allows the data to be stored and accessed later.
                  • 
+
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from itertools import groupby
+
+data = [1, 1, 2, 2, 3]
+groups = {}
+
+for key, group in groupby(data):
+    groups[key] = group  # Noncompliant
+
+for key, group in groups.items():
+    print(f"{key}: {list(group)}")  # Empty results
+
                
+
                Compliant solution
                
+
                +from itertools import groupby
+
+data = [1, 1, 2, 2, 3]
+groups = {}
+
+for key, group in groupby(data):
+    groups[key] = list(group)  # Convert to list immediately
+
+for key, group in groups.items():
+    print(f"{key}: {group}")  # Correct results
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8516.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8516.json
new file mode 100644
index 0000000000..fddc587200
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8516.json
@@ -0,0 +1,24 @@
+{
+  "title": "Group iterators from \"itertools.groupby\" should not be reused",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pitfall",
+    "confusing"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8516",
+  "sqKey": "S8516",
+  "scope": "All",
+  "quickfix": "partial",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8517.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8517.html
new file mode 100644
index 0000000000..c499adcbc5
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8517.html
@@ -0,0 +1,64 @@
+
                This rule raises an issue when sorted() with indexing ([0] or [-1]) is used to find the minimum or maximum
+value in a collection, including variants with reverse=True.
                
+
                Why is this an issue?
                
+
                When you need to find the smallest or largest element in a collection, you might be tempted to sort the entire collection and then access the first
+or last element. However, this approach is inefficient and makes your code harder to understand.
                
+
                The sorted() function creates a new sorted list from all elements, an O(n log n) operation in time, plus O(n) in memory. After
+sorting, you only use one element and discard the rest.
                
+
                Python provides built-in min() and max() functions that find the smallest or largest element in a single pass (O(n) time)
+with no extra memory allocation. They also make your intent immediately clear to anyone reading the code.
                
+
                min(), max(), and sorted() all support an optional key parameter, so you can preserve custom
+comparison logic. Note that min() and max() do not have a reverse parameter, so when replacing
+sorted(iterable, reverse=True)[0], you should use max(iterable) instead, and vice versa for [-1].
                
+
                What is the potential impact?
                
+
                  
+  
                • Performance degradation: sorting takes O(n log n) operations while min() or max() take only O(n). For
+  large collections, this difference results in noticeably slower execution.
                  • 
+  
                • Memory overhead: sorted() creates a new list containing all elements. min() and max()
+  only store a single element during execution.
                  • 
+  
                • Reduced code clarity: using sorted()[0] to find a minimum value obscures the intent of the code.
                  • 
+
                
+
                How to fix it
                
+
                Replace sorted(iterable)[0] with min(iterable) and sorted(iterable)[-1] with max(iterable).
+When reverse=True is used, the mapping is inverted: sorted(iterable, reverse=True)[0] becomes max(iterable) and
+sorted(iterable, reverse=True)[-1] becomes min(iterable).
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +numbers = [42, 17, 93, 8, 51]
+smallest = sorted(numbers)[0]  # Noncompliant
+
                
+
                Compliant solution
                
+
                +numbers = [42, 17, 93, 8, 51]
+smallest = min(numbers)
+
                
+
                Noncompliant code example
                
+
                +numbers = [42, 17, 93, 8, 51]
+largest = sorted(numbers)[-1]  # Noncompliant
+
                
+
                Compliant solution
                
+
                +numbers = [42, 17, 93, 8, 51]
+largest = max(numbers)
+
                
+
                Noncompliant code example
                
+
                +numbers = [42, 17, 93, 8, 51]
+largest = sorted(numbers, reverse=True)[0]  # Noncompliant
+
                
+
                Compliant solution
                
+
                +numbers = [42, 17, 93, 8, 51]
+largest = max(numbers)
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8517.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8517.json
new file mode 100644
index 0000000000..e4b8a5ccc6
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8517.json
@@ -0,0 +1,24 @@
+{
+  "title": "\"sorted()\" should not be used with indexing to find minimum or maximum values",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "performance",
+    "pythonic"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8517",
+  "sqKey": "S8517",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "EFFICIENT"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8518.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8518.html
new file mode 100644
index 0000000000..3932749aeb
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8518.html
@@ -0,0 +1,45 @@
+
                This rule raises an issue when a loop iterates over enumerate() but accesses list elements by index instead of unpacking the value
+directly from the enumeration.
                
+
                Why is this an issue?
                
+
                The enumerate() function in Python is designed to provide both the index and the value of each element when iterating over a sequence.
+It returns tuples in the form (index, value) for each iteration.
                
+
                When you use enumerate() in a loop but only unpack the index, then use that index to access the list element via subscript notation
+(e.g., lst[i]), you are performing an unnecessary lookup operation. The value you are looking up is already available from
+enumerate() itself - you are simply not capturing it.
                
+
                This pattern does not take advantage of a built-in feature of enumerate() and results in:
                
+
                  
+  
                • unnecessary operations: the list subscript operation is redundant since enumerate() already provides the
+  value
                  • 
+  
                • reduced readability: the code is more verbose than necessary and obscures the intent
                  • 
+  
                • performance overhead: while minor, each subscript operation requires a lookup that could be avoided
                  • 
+
                
+
                The Pythonic approach is to unpack both values from the tuple that enumerate() returns. This makes the code clearer, more efficient,
+and more idiomatic.
                
+
                What is the potential impact?
                
+
                Non-idiomatic code patterns increase the cognitive load for developers maintaining the codebase. Over time, redundant index lookups can also mask
+bugs when the sequence is modified between the enumerate() call and the subscript access.
                
+
                How to fix it
                
+
                Unpack both the index and value from the enumerate() tuple directly in the loop declaration. Replace the subscript access with the
+unpacked value variable.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +fruits = ['apple', 'banana', 'cherry']
+
+for i, fruit in enumerate(fruits):
+    print(f"Index {i}: {fruits[i]}")  # Noncompliant: use the unpacked value instead of "fruits[i]"
+
                
+
                Compliant solution
                
+
                +fruits = ['apple', 'banana', 'cherry']
+
+for i, fruit in enumerate(fruits):
+    print(f"Index {i}: {fruit}")
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8518.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8518.json
new file mode 100644
index 0000000000..783ccbd00d
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8518.json
@@ -0,0 +1,25 @@
+{
+  "title": "\"enumerate()\" values should be unpacked instead of using index lookups",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "2min"
+  },
+  "tags": [
+    "pythonic",
+    "readability",
+    "performance"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8518",
+  "sqKey": "S8518",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8519.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8519.html
new file mode 100644
index 0000000000..4fe9011c70
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8519.html
@@ -0,0 +1,56 @@
+
                This rule raises an issue when code uses list(iterable)[0] to retrieve the first element of an iterable.
                
+
                Why is this an issue?
                
+
                Using list(iterable)[0] to get the first element of an iterable is inefficient because it materializes the entire iterable into a list
+in memory before accessing the first element.
                
+
                This approach has two main problems:
                
+
                  
+  
                • Memory overhead: The entire iterable is converted to a list, consuming memory proportional to its size. For large iterables or
+  generators, this can waste significant memory.
                  • 
+  
                • Time complexity: Creating the list is an O(n) operation, where n is the number of elements in the iterable. You pay the cost of
+  iterating through all elements even though you only need the first one.
                  • 
+
                
+
                The pattern is particularly problematic with:
                
+
                  
+  
                • large datasets or database query results
                  • 
+  
                • generator expressions and generator functions
                  • 
+  
                • file readers or network streams
                  • 
+  
                • infinite iterables, which will cause the program to hang or crash
                  • 
+
                
+
                What is the potential impact?
                
+
                  
+  
                • applications may become unresponsive or crash due to out-of-memory errors when processing large datasets
                  • 
+  
                • execution time increases unnecessarily, degrading user experience in performance-critical paths
                  • 
+  
                • infinite iterables cannot be consumed at all, causing the program to hang
                  • 
+  
                • infrastructure costs grow as data size increases due to wasted memory and CPU cycles
                  • 
+
                
+
                How to fix it
                
+
                Replace list(iterable)[0] with next(iter(iterable)) to retrieve only the first element without materializing the entire
+iterable into a list. The iter() function creates an iterator, and next() retrieves the next item from that iterator, in
+O(1) time and without allocating memory for the entire collection.
                
+
                Note that the two expressions differ in the exception raised when the iterable is empty: list(iterable)[0] raises
+IndexError, while next(iter(iterable)) raises StopIteration. If the surrounding code catches
+IndexError, update the handler after applying this fix.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +def get_first_user(users):
+    return list(users)[0]  # Noncompliant
+
                
+
                Compliant solution
                
+
                +def get_first_user(users):
+    return next(iter(users))
+
                
+
                Resources
                
+
                Documentation
                
+
+
                External coding guidelines
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8519.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8519.json
new file mode 100644
index 0000000000..5f18b7d0c0
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8519.json
@@ -0,0 +1,24 @@
+{
+  "title": "\"list(...)[0]\" should not be used to get the first element",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "performance",
+    "pythonic"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8519",
+  "sqKey": "S8519",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM"
+    },
+    "attribute": "EFFICIENT"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8520.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8520.html
new file mode 100644
index 0000000000..fb3b285eca
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8520.html
@@ -0,0 +1,38 @@
+
                This rule raises an issue when sum() is called with an empty list ([]) as the start parameter to concatenate or flatten
+lists.
                
+
                Why is this an issue?
                
+
                Using sum(list_of_lists, []) to concatenate lists is a common anti-pattern in Python. Because each + concatenation
+creates a new list and copies all previous elements into it, the overall operation has quadratic time complexity O(n2) instead of the
+linear O(n) that proper alternatives achieve.
                
+
                Additionally, sum() is designed for numeric addition, not list operations. Using it for lists is semantically unclear and may confuse
+other developers reading the code.
                
+
                What is the potential impact?
                
+
                  
+  
                • performance degradation: operations that should take milliseconds can take seconds or even minutes with large datasets
                  • 
+  
                • memory pressure: each intermediate concatenation allocates a new list, creating unnecessary memory overhead
                  • 
+  
                • scalability issues: code that works fine in development with small datasets may become unusable in production
                  • 
+
                
+
                How to fix it
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +list_of_lists = [[1, 2], [3, 4], [5, 6]]
+result = sum(list_of_lists, [])  # Noncompliant
+
                
+
                Compliant solution
                
+
                +import itertools
+
+list_of_lists = [[1, 2], [3, 4], [5, 6]]
+result = list(itertools.chain.from_iterable(list_of_lists))
+
                
+
                How does this work?
                
+
                itertools.chain.from_iterable() creates an iterator that yields elements from each sub-list in sequence without creating intermediate
+list copies. This avoids the repeated copying that causes the quadratic behavior of sum() and results in linear O(n) time complexity.
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8520.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8520.json
new file mode 100644
index 0000000000..7e638c3e67
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8520.json
@@ -0,0 +1,24 @@
+{
+  "title": "\"sum()\" should not be used with an empty list to concatenate lists",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "performance",
+    "pitfall"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8520",
+  "sqKey": "S8520",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "EFFICIENT"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8521.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8521.html
new file mode 100644
index 0000000000..1d718a9356
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8521.html
@@ -0,0 +1,40 @@
+
                This rule raises an issue when .keys() is called explicitly on a dictionary for membership testing.
                
+
                Why is this an issue?
                
+
                In Python, dictionaries support direct membership testing without needing to explicitly call the .keys() method. When you write
+key in dict.keys(), you are being unnecessarily verbose.
                
+
                The expression key in dict is the idiomatic Python way to check for key membership. It is:
                
+
                  
+  
                • more readable: the intent is clearer and the code is shorter
                  • 
+  
                • slightly more efficient: it avoids creating an intermediate dictionary view object
                  • 
+  
                • more Pythonic: it follows Python’s principle of having one obvious way to do it
                  • 
+
                
+
                The .keys() method exists primarily for cases where you need to perform set operations on dictionary keys or when you need an explicit
+view object. For simple membership testing, it is redundant because dictionaries are designed to support the in operator directly.
                
+
                What is the potential impact?
                
+
                Unnecessarily verbose code patterns accumulate over a codebase and reduce readability. Following Python idioms makes code easier to review and
+maintain, and helps new contributors understand the codebase faster.
                
+
                How to fix it
                
+
                Remove the .keys() call and use direct membership testing on the dictionary. This is the standard Python idiom for checking if a key
+exists in a dictionary.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +my_dict = {'a': 1, 'b': 2, 'c': 3}
+
+if 'a' in my_dict.keys():  # Noncompliant
+    print('Found')
+
                
+
                Compliant solution
                
+
                +my_dict = {'a': 1, 'b': 2, 'c': 3}
+
+if 'a' in my_dict:
+    print('Found')
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8521.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8521.json
new file mode 100644
index 0000000000..f904a51094
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8521.json
@@ -0,0 +1,24 @@
+{
+  "title": "Dictionary membership tests should not explicitly call \".keys()\"",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "1 min"
+  },
+  "tags": [
+    "pythonic",
+    "idiom"
+  ],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-8521",
+  "sqKey": "S8521",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8554.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8554.html
new file mode 100644
index 0000000000..73021deb20
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8554.html
@@ -0,0 +1,65 @@
+
                This rule raises an issue when logging statements violate established Python logging best practices, including using eager string formatting,
+deprecated methods, or attribute name collisions in the 'extra' parameter.
                
+
                Why is this an issue?
                
+
                Python’s logging module has specific patterns that ensure correctness, performance, and maintainability. Violating these patterns can lead to
+several problems:
                
+
                Eager String Formatting
                
+
                When you format strings before passing them to logging methods (using f-strings, .format(), % operator, or +
+concatenation), Python performs the string formatting operation immediately, even if the log message won’t be output due to the current log level.
+This wastes CPU cycles on string operations that may never be used.
                
+
                The logging module supports lazy formatting by accepting format arguments as separate parameters. The formatting only occurs when the logging
+framework confirms the message will actually be logged based on the configured log level.
                
+
                Deprecated Methods
                
+
                The logging.warn() and logging.Logger.warn() methods are deprecated. While they still function, they may be removed in
+future Python versions. The recommended methods are logging.warning() and logging.Logger.warning(), which are functionally
+equivalent.
                
+
                Attribute Name Collisions
                
+
                The logging module’s extra keyword argument allows passing additional values to be included in log records. However, if the keys in
+the extra dictionary clash with built-in LogRecord attributes (such as 'name', 'msg', 'args', 'created', 'filename',
+'funcName', 'levelname', 'levelno', 'lineno', 'module', 'msecs', 'message', 'pathname', 'process', 'processName', 'relativeCreated', 'thread',
+'threadName'), a KeyError will be raised when the LogRecord is constructed, causing the logging statement to fail at
+runtime.
                
+
                What is the potential impact?
                
+
                Performance degradation: Eager string formatting can significantly impact application performance, especially in code paths with frequent logging
+statements. When log levels are configured to filter out certain messages (for example, DEBUG messages in production), the application still pays the
+cost of formatting strings that will never be logged.
                
+
                Runtime errors: Attribute name collisions in the extra parameter raise KeyError exceptions, causing logging statements to
+fail unexpectedly.
                
+
                Maintenance issues: Using deprecated methods creates technical debt. When these methods are eventually removed from Python, code using them will
+break. Additionally, mixing deprecated and non-deprecated methods across a codebase creates inconsistency and confusion.
                
+
                Inconsistent logging: Eager formatting can lead to inconsistent behavior across different log handlers. When using lazy formatting with the
+extra parameter, all handlers receive the same structured data and can format it consistently according to their configuration.
                
+
                How to fix it
                
+
                Use lazy formatting by passing format arguments as separate parameters to logging methods instead of formatting strings before the call. Replace
+f-strings, .format(), % operator, and + concatenation with %-style placeholders and separate arguments.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import logging
+
+user = "Maria"
+logging.info(f"{user} - Something happened")  # Noncompliant: f-string formatting
+
+logging.info("{} - Something happened".format(user))  # Noncompliant: .format() method
+
+logging.info("%s - Something happened" % user)  # Noncompliant: % operator formatting
+
+logging.info(user + " - Something happened")  # Noncompliant: string concatenation
+
                
+
                Compliant solution
                
+
                +import logging
+
+user = "Maria"
+logging.info("%s - Something happened", user)  # Compliant: lazy formatting with separate argument
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8554.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8554.json
new file mode 100644
index 0000000000..550aae68bb
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8554.json
@@ -0,0 +1,26 @@
+{
+  "title": "Logging statements should follow Python best practices",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "convention",
+    "performance",
+    "pitfall"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8554",
+  "sqKey": "S8554",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "LOW",
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8572.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8572.html
new file mode 100644
index 0000000000..f319ee1b69
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8572.html
@@ -0,0 +1,55 @@
+
                This rule raises an issue when logging.error() is used within an exception handler (except block) to log exception
+information.
                
+
                Why is this an issue?
                
+
                When handling exceptions in Python, it’s important to capture not just the error message, but also the full traceback. The traceback shows the
+sequence of function calls that led to the exception, which is essential for understanding what went wrong and where.
                
+
                The logging module provides two methods that might seem similar:
                
+
                  
+  
                • logging.error(): Logs an error message at the ERROR level
                  • 
+  
                • logging.exception(): Logs an error message at the ERROR level AND automatically includes the full exception traceback
                  • 
+
                
+
                When you’re inside an exception handler (except block), you’re dealing with an exception that just occurred. In this context,
+logging.exception() is the appropriate choice because:
                
+
                  
+  
                • It automatically captures the traceback without requiring exc_info=True
                  • 
+  
                • It clearly signals to other developers that you’re logging an exception
                  • 
+  
                • It is the purpose-built method for logging exceptions and is the established Python idiom for this use case
                  • 
+
                
+
                Using logging.error() in an exception handler means you’re either:
                
+
                  
+  
                • Missing the traceback entirely (if you don’t pass exc_info=True), making debugging much harder
                  • 
+  
                • Writing more verbose code (if you do pass exc_info=True) when a simpler, more idiomatic option exists
                  • 
+
                
+
                The logging.exception() method is specifically designed for this use case and is the established Python idiom for logging
+exceptions.
                
+
                How to fix it
                
+
                Replace logging.error() with logging.exception() when logging within an exception handler. If you were using
+exc_info=True, you can remove it since logging.exception() includes traceback information by default.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import logging
+
+try:
+    raise ValueError("Invalid value")
+except ValueError:
+    logging.error("Exception occurred", exc_info=True)  # Noncompliant
+
                
+
                Compliant solution
                
+
                +import logging
+
+try:
+    raise ValueError("Invalid value")
+except ValueError:
+    logging.exception("Exception occurred")
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8572.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8572.json
new file mode 100644
index 0000000000..0546ca1f75
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8572.json
@@ -0,0 +1,24 @@
+{
+  "title": "\"logging.exception()\" should be used instead of \"logging.error()\" in exception handlers",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "logging",
+    "exception"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8572",
+  "sqKey": "S8572",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "COMPLETE"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8685.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8685.html
new file mode 100644
index 0000000000..ed00e53b53
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8685.html
@@ -0,0 +1,72 @@
+
                Using a mutable or stateful value as a default for a dataclass attribute is rarely what developers intend. The value is evaluated only once, when
+the class is defined, so every instance shares the same object.
                
+
                Why is this an issue?
                
+
                Default values for dataclass attributes are evaluated once when the class is defined, not each time an instance is created. This is a fundamental
+aspect of how Python evaluates default values.
                
+
                When the default is produced by calling a function such as datetime.now() or uuid.uuid4(), or by a mutable container like
+[] or list(), the value is computed once and reused across every instance of the dataclass. Every instance therefore ends up
+with the same object.
                
+
                +@dataclass
+class Event:
+    timestamp: datetime = datetime.now()  # Noncompliant
+    tags: list = []  # Noncompliant
+
+event1 = Event()
+event2 = Event()
+event1.tags.append("x")
+# event2.tags is also ["x"] — tags is the same list object.
+# event1.timestamp and event2.timestamp are both the class-definition time.
+
                
+
                In this example, event1 and event2 share the same tags list and the same timestamp.
                
+
                What is the potential impact?
                
+
                Using such defaults can cause reliability issues:
                
+
                  
+  
                • Broken uniqueness: attributes meant to be unique per instance, such as UUIDs or timestamps, become identical across all
+  instances.
                  • 
+  
                • State sharing bugs: mutating the default through one instance silently affects every other instance and every instance created
+  in the future.
                  • 
+  
                • Incorrect business logic: time-sensitive operations use a stale timestamp captured at class definition, which leads to
+  incorrect ordering, expiration, or logging.
                  • 
+  
                • Hard-to-diagnose bugs: the issue may not be visible in short-lived tests, but appears in production where instances are created
+  over a longer period of time or mutate their state.
                  • 
+
                
+
                How to fix it
                
+
                Use field(default_factory=…​) instead. The default_factory parameter accepts a callable, without parentheses, that is
+invoked each time a new instance is created, so each instance receives a fresh value.
                
+
                The default_factory expects a callable with no arguments. If the function requires arguments, wrap it in a lambda or use
+functools.partial.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +@dataclass
+class Event:
+    timestamp: datetime = datetime.now()  # Noncompliant
+    event_id: uuid.UUID = uuid.uuid4()  # Noncompliant
+    tags: list = []  # Noncompliant
+
                
+
                Compliant solution
                
+
                +from dataclasses import dataclass, field
+
+@dataclass
+class Event:
+    timestamp: datetime = field(default_factory=datetime.now)
+    event_id: uuid.UUID = field(default_factory=uuid.uuid4)
+    tags: list = field(default_factory=list)
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S6891} - Mutable objects should not be used as default parameter values
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8685.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8685.json
new file mode 100644
index 0000000000..d10637e759
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8685.json
@@ -0,0 +1,24 @@
+{
+  "title": "Mutable or stateful values should not be used as default values in dataclass attributes",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "dataclass",
+    "pitfall"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8685",
+  "sqKey": "S8685",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8714.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8714.html
new file mode 100644
index 0000000000..39ea0b3adb
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8714.html
@@ -0,0 +1,141 @@
+
                This rule raises an issue when a test uses a try-except block combined with fail() to verify whether an exception is
+raised or not raised.
                
+
                Why is this an issue?
                
+
                Using try-except blocks combined with fail() to test for the presence or absence of exceptions is an anti-pattern.
                
+
                Modern testing frameworks like pytest and Python’s built-in unittest provide dedicated assertion methods that make
+exception testing cleaner and more explicit. These methods eliminate boilerplate code, clearly communicate test intent, and make it easier to assert
+on exception details.
                
+
                The try-except-fail() pattern has several drawbacks:
                
+
                  
+  
                • It adds unnecessary boilerplate that obscures the test’s purpose
                  • 
+  
                • It requires manual exception handling instead of using framework features
                  • 
+  
                • It makes the test harder to maintain and read
                  • 
+  
                • It provides no straightforward way to assert on exception attributes when an exception is expected
                  • 
+
                
+
                Dedicated exception assertions solve these problems by providing a declarative way to express exception expectations.
                
+
                What is the potential impact?
                
+
                Using try-except with fail() instead of dedicated exception assertions reduces test code quality and maintainability:
                
+
                  
+  
                • Readability: Tests become harder to understand at a glance, especially for developers unfamiliar with the codebase
                  • 
+  
                • Maintainability: More verbose code means more places for bugs to hide and more effort required to update tests
                  • 
+  
                • Intent clarity: The test’s purpose (verifying exception behavior) is buried in control flow rather than being explicit
                  • 
+  
                • Lost functionality: It’s harder to assert on exception messages, types, or other attributes when using the
+  try-except pattern
                  • 
+
                
+
                How to fix it in unittest
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                Replace try-except blocks that use fail() with assertRaises used as a context manager. This built-in method
+from Python’s unittest framework provides a clean way to verify exception behavior.
                
+
                When you expect no exception, simply call the code directly without wrapping it in a try-except block. If an unexpected exception is
+raised, the test framework will catch it and fail the test automatically.
                
+
                When you expect an exception, use assertRaises as a context manager. This allows you to capture the exception and make additional
+assertions on its properties.
                
+
                +import unittest
+
+class UserServiceTest(unittest.TestCase):
+    def test_no_exception_thrown(self):
+        try:
+            self.user_service.register_user(self.valid_user)
+        except ValidationError:
+            self.fail("Should not have thrown any exception")  # Noncompliant
+
                
+
                When verifying that an exception is raised, use assertRaises as a context manager. This provides access to the exception object for
+further assertions.
                
+
                +import unittest
+
+class UserServiceTest(unittest.TestCase):
+    def test_exception_is_thrown(self):
+        try:
+            self.user_service.register_user(self.invalid_user)
+            self.fail("Expected ValidationError to be thrown")  # Noncompliant
+        except ValidationError as e:
+            self.assertEqual("Invalid email", str(e))
+
                
+
                Compliant solution
                
+
                Replace try-except blocks that use fail() with assertRaises used as a context manager. This built-in method
+from Python’s unittest framework provides a clean way to verify exception behavior.
                
+
                When you expect no exception, simply call the code directly without wrapping it in a try-except block. If an unexpected exception is
+raised, the test framework will catch it and fail the test automatically.
                
+
                When you expect an exception, use assertRaises as a context manager. This allows you to capture the exception and make additional
+assertions on its properties.
                
+
                +import unittest
+
+class UserServiceTest(unittest.TestCase):
+    def test_no_exception_thrown(self):
+        # Simply call the method - unittest will fail if an exception is raised
+        self.user_service.register_user(self.valid_user)
+
                
+
                When verifying that an exception is raised, use assertRaises as a context manager. This provides access to the exception object for
+further assertions.
                
+
                +import unittest
+
+class UserServiceTest(unittest.TestCase):
+    def test_exception_is_thrown(self):
+        with self.assertRaises(ValidationError) as context:
+            self.user_service.register_user(self.invalid_user)
+
+        self.assertEqual("Invalid email", str(context.exception))
+
                
+
                How to fix it in pytest
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                Replace try-except blocks with pytest.raises used as a context manager. Pytest is the most popular Python testing
+framework and provides excellent exception testing support.
                
+
                When you expect no exception, simply call the code directly. Pytest will fail the test if an unexpected exception occurs.
                
+
                When you expect an exception, use pytest.raises as a context manager to verify the exception type and optionally inspect its
+properties.
                
+
                +import pytest
+
+def test_no_exception_thrown(user_service, valid_user):
+    try:
+        user_service.register_user(valid_user)
+    except ValidationError:
+        pytest.fail("Should not have thrown any exception")  # Noncompliant
+
                
+
                When verifying that an exception is raised with pytest, use pytest.raises as a context manager. This gives you access to the exception
+object for additional assertions using the match parameter or the value attribute.
                
+
                +import pytest
+
+def test_exception_is_thrown(user_service, invalid_user):
+    try:
+        user_service.register_user(invalid_user)
+        pytest.fail("Expected ValidationError to be thrown")  # Noncompliant
+    except ValidationError as e:
+        assert str(e) == "Invalid email"
+
                
+
                Compliant solution
                
+
                Replace try-except blocks with pytest.raises used as a context manager. Pytest is the most popular Python testing
+framework and provides excellent exception testing support.
                
+
                When you expect no exception, simply call the code directly. Pytest will fail the test if an unexpected exception occurs.
                
+
                When you expect an exception, use pytest.raises as a context manager to verify the exception type and optionally inspect its
+properties.
                
+
                +def test_no_exception_thrown(user_service, valid_user):
+    # Simply call the method - pytest will fail if an exception is raised
+    user_service.register_user(valid_user)
+
                
+
                When verifying that an exception is raised with pytest, use pytest.raises as a context manager. This gives you access to the exception
+object for additional assertions using the match parameter or the value attribute.
                
+
                +import pytest
+
+def test_exception_is_thrown(user_service, invalid_user):
+    with pytest.raises(ValidationError) as exc_info:
+        user_service.register_user(invalid_user)
+
+    assert str(exc_info.value) == "Invalid email"
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8714.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8714.json
new file mode 100644
index 0000000000..1c41e60595
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8714.json
@@ -0,0 +1,23 @@
+{
+  "title": "Dedicated exception assertions should be used instead of \"try-except\" with \"fail()\"",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "tests"
+  ],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-8714",
+  "sqKey": "S8714",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8786.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8786.html
new file mode 100644
index 0000000000..c4b33d6da0
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8786.html
@@ -0,0 +1,59 @@
+
                Regular expression engines rely on backtracking to evaluate patterns against input. Certain regex patterns lead to non-linear backtracking, where
+the evaluation time grows polynomially with input size.
                
+
                Why is this an issue?
                
+
                Regular expression engines use backtracking to try all possible execution paths when evaluating a pattern against an input. In some cases, this
+leads to non-linear backtracking where the worst-case evaluation time grows polynomially (e.g., O(n²) or O(n³)) with the input size. While not as
+severe as catastrophic backtracking, such patterns can significantly degrade application performance when processing large or untrusted inputs.
                
+
                This rule reports regular expressions that exhibit non-linear backtracking behavior.
                
+
                How to fix it
                
+
                To fix a regular expression with non-linear backtracking, consider the following strategies:
                
+
                  
+  
                • Replace . with negated character classes to exclude separators where applicable (e.g., 
+  instead of . before ,).
                  • 
+  
                • Use bounded quantifiers such as {1,5} to limit repetitions.
                  • 
+  
                • Restructure alternations and quantifiers to eliminate ambiguity — avoid patterns where multiple alternatives can match the same character.
                  • 
+  
                • Use possessive quantifiers and atomic grouping (available since Python 3.11) to prevent the regex engine from keeping backtracking
+  positions.
                  • 
+
                
+
                Code examples
                
+
                The following examples illustrate two distinct causes of non-linear backtracking. The first shows a pattern that is polynomial when unanchored:
+without a start anchor, the engine retries the pattern at every position, leading to quadratic evaluation time when there is no match. The second
+shows ambiguous alternation, which causes quadratic backtracking regardless of anchoring because multiple alternatives can match the same input in
+different ways.
                
+
                Noncompliant code example
                
+
                +import re
+
+re.search(r"a+b", text)  # Noncompliant - polynomial backtracking when the pattern does not match
+
                
+
                +import re
+
+re.search(r"(a|aa)+", text)  # Noncompliant - ambiguous alternation causes quadratic backtracking
+
                
+
                Compliant solution
                
+
                Adding a start anchor prevents the engine from retrying at every position:
                
+
                +import re
+
+re.search(r"^a+b", text)  # Compliant - anchor eliminates redundant backtracking positions
+
                
+
                Restructuring the alternation to eliminate the overlap removes the quadratic behavior:
                
+
                +import re
+
+re.search(r"a+", text)  # Compliant - unambiguous
+
                
+
                Resources
                
+
                Articles & blog posts
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S5852} - Regular expressions should not cause catastrophic backtracking
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8786.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8786.json
new file mode 100644
index 0000000000..236ff5b14d
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8786.json
@@ -0,0 +1,24 @@
+{
+  "title": "Regular expressions should not cause non-linear backtracking",
+  "type": "CODE_SMELL",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM"
+    },
+    "attribute": "EFFICIENT"
+  },
+  "status": "ready",
+  "quickfix": "unknown",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "20min"
+  },
+  "tags": [
+    "regex",
+    "performance"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8786",
+  "sqKey": "S8786",
+  "scope": "All"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8900.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8900.html
new file mode 100644
index 0000000000..36b8d86f8d
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8900.html
@@ -0,0 +1,223 @@
+
                This is an issue when you use deprecated methods from a previous major version of an HTML/XML parsing library, particularly methods that follow an
+older naming convention (such as camelCase methods) that have been superseded by methods using a different naming convention in the current
+version.
                
+
                In Python with Beautiful Soup 4, this applies to:
                
+
                  
+  
                • Deprecated camelCase method names carried over from Beautiful Soup 3, such as findAll(), findChildren(),
+  findParent(), and findNext()
                  • 
+  
                • Deprecated camelCase attribute names such as nextSibling and previousSibling
                  • 
+  
                • The deprecated text= keyword argument to search methods, replaced by string=
                  • 
+
                
+
                Why is this an issue?
                
+
                A major version update of this parsing library introduced a more consistent naming convention for its methods. The old naming convention from the
+previous major version (like methods following the earlier style) was kept for backward compatibility but marked as deprecated.
                
+
                While these deprecated methods still work in current versions, they create several problems:
                
+
                  
+  
                • Inconsistent code style: Mixing deprecated methods with modern methods makes your codebase harder to read and understand.
                  • 
+  
                • Future compatibility risk: Deprecated methods may be removed in future library versions, breaking your code.
                  • 
+  
                • Confusion for maintainers: Developers familiar with the modern API will find deprecated methods unexpected and may not
+  understand why they’re being used.
                  • 
+
                
+
                The library’s documentation explicitly recommends using the modern equivalents to ensure long-term code maintainability.
                
+
                In Beautiful Soup specifically, this refers to the transition from Beautiful Soup 3’s camelCase naming (like findAll(),
+nextSibling) to Beautiful Soup 4’s underscore-separated naming convention (like find_all(), next_sibling).
                
+
                What is the potential impact?
                
+
                Using deprecated methods creates technical debt that will require refactoring effort later. When the library eventually removes these methods, your
+application may break unexpectedly during a dependency update, requiring emergency fixes. This is especially problematic in production environments
+where dependency updates should be routine maintenance rather than risky operations.
                
+
                How to fix it
                
+
                Replace the deprecated name with its modern equivalent. The full list of replacements is:
                
+
+  +    +    +  
+  
+    
+      
+      
+    
+  
+  
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+    
+      
+      
+    
+  
+
                



                Deprecated nameModern equivalent
                
+        
                findAll()
                
+                      		
+        
                find_all()
                
+      
                
+        
                findChild()
                
+                      		
+        
                find()
                
+      
                
+        
                findChildren()
                
+                      		
+        
                find_all()
                
+      
                
+        
                findNext()
                
+                      		
+        
                find_next()
                
+      
                
+        
                findAllNext()
                
+                      		
+        
                find_all_next()
                
+      
                
+        
                findPrevious()
                
+                      		
+        
                find_previous()
                
+      
                
+        
                findAllPrevious()
                
+                      		
+        
                find_all_previous()
                
+      
                
+        
                findNextSibling()
                
+                      		
+        
                find_next_sibling()
                
+      
                
+        
                findNextSiblings()
                
+                      		
+        
                find_next_siblings()
                
+      
                
+        
                findPreviousSibling()
                
+                      		
+        
                find_previous_sibling()
                
+      
                
+        
                findPreviousSiblings()
                
+                      		
+        
                find_previous_siblings()
                
+      
                
+        
                findParent()
                
+                      		
+        
                find_parent()
                
+      
                
+        
                findParents()
                
+                      		
+        
                find_parents()
                
+      
                
+        
                replaceWith()
                
+                      		
+        
                replace_with()
                
+      
                
+        
                getText()
                
+                      		
+        
                get_text()
                
+      
                
+        
                .nextSibling
                
+                      		
+        
                .next_sibling
                
+      
                
+        
                .previousSibling
                
+                      		
+        
                .previous_sibling
                
+      
                
+        
                text= argument in find*() methods
                
+                      		
+        
                string= argument
                
+      
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup(html, 'html.parser')
+result = soup.find_all('a', text='Click here')  # Noncompliant
+
                
+
                Compliant solution
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup(html, 'html.parser')
+result = soup.find_all('a', string='Click here')
+
                
+
                Noncompliant code example
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup(html, 'html.parser')
+result = soup.findAll('a', string='Click here')  # Noncompliant
+
                
+
                Compliant solution
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup(html, 'html.parser')
+result = soup.find_all('a', string='Click here')
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8900.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8900.json
new file mode 100644
index 0000000000..f188656f89
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8900.json
@@ -0,0 +1,25 @@
+{
+  "title": "Deprecated Beautiful Soup methods should be replaced with their modern equivalents",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "deprecated",
+    "convention",
+    "pythonic"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8900",
+  "sqKey": "S8900",
+  "scope": "All",
+  "quickfix": "covered",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8903.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8903.html
new file mode 100644
index 0000000000..c209746703
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8903.html
@@ -0,0 +1,60 @@
+
                This rule raises an issue when HTML elements are inserted into an in-memory document structure using methods that add content nodes with raw HTML
+strings.
                
+
                In Python, this specifically refers to BeautifulSoup operations such as insert(), append(), and extend()
+that add HTML content to the document tree.
                
+
                Why is this an issue?
                
+
                Document parsing and manipulation libraries provide APIs for building and modifying HTML and XML document trees. When working with these libraries,
+you need to add new elements to the document structure programmatically.
                
+
                A common mistake is to insert raw markup strings directly into the document tree. When you do this, the library treats the string as text content
+rather than markup. This means all markup special characters get escaped:
                
+
                  
+  
                • < becomes &lt;
                  • 
+  
                • > becomes &gt;
                  • 
+  
                • " becomes &quot;
                  • 
+
                
+
                As a result, instead of creating actual elements in the document tree, you end up with visible text that looks like markup code on the rendered
+page. The document structure becomes invalid, and the intended functionality is lost.
                
+
                Factory methods provided by the library are the correct API for creating new elements programmatically. These methods create proper element objects
+that integrate seamlessly into the document tree. You specify the element name as the first argument and can pass attributes as additional
+parameters.
                
+
                Using factory methods ensures:
                
+
                  
+  
                • Elements are created as actual element objects, not text
                  • 
+  
                • Attributes are properly set without manual string formatting
                  • 
+  
                • The document structure remains valid
                  • 
+  
                • The code is more readable and maintainable
                  • 
+
                
+
                In Python’s BeautifulSoup library specifically, this factory method is called new_tag().
                
+
                What is the potential impact?
                
+
                The incorrect HTML structure will cause the web page to display escaped HTML text instead of rendering the intended elements. This breaks the
+application’s functionality and user interface. Users will see literal HTML code like angle brackets and tag names displayed as text instead of the
+intended page structure.
                
+
                How to fix it
                
+
                Replace raw HTML string insertion with the new_tag() factory method. Create the tag object first by calling
+soup.new_tag() with the tag name and attributes, then insert it into the document tree.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup('<html><body></body></html>', 'html.parser')
+soup.body.insert(0, '<div id="file_history"></div>')  # Noncompliant
+
                
+
                Compliant solution
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup('<html><body></body></html>', 'html.parser')
+new_tag = soup.new_tag('div', id='file_history')
+soup.body.insert(0, new_tag)
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8903.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8903.json
new file mode 100644
index 0000000000..5351c4309c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8903.json
@@ -0,0 +1,26 @@
+{
+  "title": "HTML elements should be created with \"new_tag()\" instead of inserting raw HTML strings",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "html",
+    "api",
+    "pitfall"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8903",
+  "sqKey": "S8903",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8904.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8904.html
new file mode 100644
index 0000000000..8b2992cda3
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8904.html
@@ -0,0 +1,176 @@
+
                This rule raises an issue when attributes, text content, or methods of BeautifulSoup elements are accessed without first checking if they
+exist.
                
+
                BeautifulSoup’s search methods like find(), find_next(), and select_one() return None when they
+cannot locate a matching element. If you try to access properties or methods on None, Python raises an AttributeError or
+TypeError, causing your program to crash.
                
+
                This commonly happens when:
                
+
                  
+  
                • You assume an HTML element will always be present in the parsed content
                  • 
+  
                • You chain multiple find() calls without intermediate checks
                  • 
+  
                • You access element attributes using subscript notation (e.g., element['href'])
                  • 
+  
                • You access the .text, .string, or other properties directly after a search
                  • 
+
                
+
                The following methods and access patterns can return None and are covered by this rule:
                
+
+  +    +    +    +  
+  
+    
+      
+      
+      
+    
+  
+  
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+    
+      
+      
+      
+    
+  
+
                




                Method / AccessDescriptionReturns None when
                
+        
                find()
                
+                      		
+        
                Searches descendants for the first tag or string matching the given criteria.
                
+                      		
+        
                No matching element exists.
                
+      
                
+        
                find_next()
                
+                      		
+        
                Finds the first tag or string that follows the current element in document order matching the given criteria.
                
+                      		
+        
                No matching element exists after the current position.
                
+      
                
+        
                find_previous()
                
+                      		
+        
                Finds the first tag or string that precedes the current element in document order matching the given criteria.
                
+                      		
+        
                No matching element exists before the current position.
                
+      
                
+        
                find_next_sibling()
                
+                      		
+        
                Finds the first sibling tag after the current element matching the given criteria.
                
+                      		
+        
                No matching sibling exists after the current element.
                
+      
                
+        
                find_previous_sibling()
                
+                      		
+        
                Finds the first sibling tag before the current element matching the given criteria.
                
+                      		
+        
                No matching sibling exists before the current element.
                
+      
                
+        
                find_parent()
                
+                      		
+        
                Finds the first parent tag matching the given criteria by traversing upward in the tree.
                
+                      		
+        
                No matching parent exists.
                
+      
                
+        
                select_one()
                
+                      		
+        
                Returns the first tag matching the given CSS selector.
                
+                      		
+        
                No element matches the CSS selector.
                
+      
                
+
                Why is this an issue?
                
+
                HTML and XML parsing libraries provide search methods to locate elements in parsed document trees. These search methods typically return a null or
+none value when they cannot find a matching element, rather than throwing an exception. This is expected behavior because:
                
+
                  
+  
                • HTML structures vary between pages and websites
                  • 
+  
                • Content may be dynamically loaded or conditionally present
                  • 
+  
                • Selectors might be incorrect or outdated
                  • 
+  
                • The page structure may change over time
                  • 
+
                
+
                The problem occurs when code assumes an element will always be found and immediately accesses its properties or methods. Attempting to operate on a
+null result causes runtime errors when:
                
+
                  
+  
                • Accessing properties like text content, tag names, or other element attributes on null values
                  • 
+  
                • Using subscript or indexing operations to access element attributes on null values
                  • 
+  
                • Calling methods to navigate the document tree or retrieve information on null values
                  • 
+  
                • Chaining multiple search operations without intermediate null checks amplifies the risk
                  • 
+
                
+
                These runtime errors cause the program to crash, often in production when encountering unexpected HTML structures. The errors can be difficult to
+diagnose because they depend on the specific content being parsed, which may vary between:
                
+
                  
+  
                • Different pages on the same website
                  • 
+  
                • The same page at different times
                  • 
+  
                • Different user sessions or geographic locations
                  • 
+  
                • Development versus production environments
                  • 
+
                
+
                What is the potential impact?
                
+
                When HTML/XML parser element references are accessed without null checks, the application crashes with null reference exceptions or type errors.
+This has several consequences:
                
+
                  
+  
                • Service disruption: Web scraping scripts fail mid-execution, leaving incomplete or corrupt data
                  • 
+  
                • Poor user experience: Applications that parse HTML for features crash unexpectedly
                  • 
+  
                • Difficult debugging: Errors only occur with specific HTML content, making them hard to reproduce
                  • 
+  
                • Data loss: Partially processed data may be lost when the program terminates
                  • 
+  
                • Maintenance burden: Developers must handle support requests and emergency fixes
                  • 
+
                
+
                The impact is particularly severe in production web scraping pipelines and applications that process user-provided HTML content.
                
+
                How to fix it
                
+
                Check if the element exists before accessing its attributes. Store the search result in a variable and verify it’s not None using a conditional
+statement. This approach makes the code self-documenting and provides a clear place to handle missing elements.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup(html_content, "html.parser")
+figure = soup.find("dd", class_="investment_sought").text  # Noncompliant
+print(figure)
+
                
+
                Compliant solution
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup(html_content, "html.parser")
+element = soup.find("dd", class_="investment_sought")
+if element:
+    figure = element.text
+    print(figure)
+else:
+    print("Element not found")
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8904.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8904.json
new file mode 100644
index 0000000000..ba202b8bc2
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8904.json
@@ -0,0 +1,25 @@
+{
+  "title": "BeautifulSoup elements should be checked for None before accessing",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "beautifulsoup",
+    "pitfall",
+    "web"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8904",
+  "sqKey": "S8904",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "COMPLETE"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8905.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8905.html
new file mode 100644
index 0000000000..e71fe8a500
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8905.html
@@ -0,0 +1,67 @@
+
                This rule raises an issue when an HTML/XML parser object is created without explicitly specifying which parsing engine to use (typically the second
+positional parameter or a named parameter in the constructor).
                
+
                In Python, this specifically refers to the BeautifulSoup object from the BeautifulSoup4 library.
                
+
                Why is this an issue?
                
+
                When you initialize an HTML parsing library without specifying which parser to use, the library automatically selects what it considers the "best
+available" parser on your system. This might seem convenient, but it creates several problems.
                
+
                The parser that the library chooses depends on which parsing libraries are installed in your environment. Common parsing strategies include a
+language’s built-in HTML parser, faster third-party parsers with native code components, and more lenient parsers that prioritize compatibility.
+Different environments—such as your local machine, a colleague’s computer, a CI/CD server, or a production deployment—may have different parsers
+installed.
                
+
                This environment-dependent behavior leads to inconsistent parsing results. Different parsers handle HTML differently, especially when dealing with
+malformed or ambiguous markup. For example:
                
+
                  
+  
                • Parsers with native code components are faster but may be stricter about HTML structure
                  • 
+  
                • Compatibility-focused parsers are more lenient and parse HTML like a web browser would
                  • 
+  
                • Built-in parsers offer a middle ground and require no external dependencies
                  • 
+
                
+
                When parsing untrusted or poorly-formed HTML from external sources, these differences can produce completely different parse trees. Code that works
+perfectly in your development environment might fail or behave unexpectedly in production. A query that successfully locates an element with one
+parser might return nothing with another.
                
+
                Beyond correctness issues, this inconsistency makes debugging difficult. When a bug appears only in certain environments, tracking down the cause
+becomes challenging if you don’t realize the parser is different.
                
+
                For security-sensitive applications that parse untrusted HTML, relying on an unspecified parser introduces additional risk. Different parsers may
+interpret potentially malicious markup differently, and you lose control over this critical parsing behavior.
                
+
                In Python’s BeautifulSoup library, the common parsers are html.parser (Python’s built-in), lxml (faster with native
+code), lxml-xml or xml (for XML documents), and html5lib (most lenient and browser-like).
                
+
                What is the potential impact?
                
+
                When HTML parsing libraries use different parsers across environments, your application may:
                
+
                  
+  
                • Parse the same HTML differently in development versus production
                  • 
+  
                • Experience bugs that only occur on certain machines or in specific deployment environments
                  • 
+  
                • Fail to extract expected data from HTML documents, causing application logic errors
                  • 
+  
                • Behave unpredictably when processing HTML from external sources
                  • 
+
                
+
                These issues reduce code reliability and make your application harder to maintain and debug.
                
+
                How to fix it
                
+
                Add the parser name as the second argument when creating a BeautifulSoup object. Python’s built-in html.parser is a good default
+choice as it requires no additional dependencies.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from bs4 import BeautifulSoup
+from urllib.request import urlopen
+
+webpage = urlopen('http://example.com')
+soup = BeautifulSoup(webpage)  # Noncompliant
+table = soup.find('table', {'class': 'data'})
+
                
+
                Compliant solution
                
+
                +from bs4 import BeautifulSoup
+from urllib.request import urlopen
+
+webpage = urlopen('http://example.com')
+soup = BeautifulSoup(webpage, 'html.parser')
+table = soup.find('table', {'class': 'data'})
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8905.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8905.json
new file mode 100644
index 0000000000..ef7b0f8495
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8905.json
@@ -0,0 +1,26 @@
+{
+  "title": "BeautifulSoup parser should be explicitly specified",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "html",
+    "unpredictable",
+    "pitfall"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8905",
+  "sqKey": "S8905",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8906.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8906.html
new file mode 100644
index 0000000000..1d7cecc853
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8906.html
@@ -0,0 +1,71 @@
+
                This rule raises an issue when a list of class names is passed to a parameter that filters HTML elements by CSS class and expect to match elements
+that have ALL the specified classes.
                
+
                In Python’s BeautifulSoup library, this specifically refers to the class_ parameter accepted by many search methods, including
+find(), find_all(), find_parent(), find_parents(), find_next_sibling(),
+find_next_siblings(), find_previous_sibling(), find_previous_siblings(), find_next(),
+find_all_next(), find_previous(), and find_all_previous().
                
+
                Why is this an issue?
                
+
                In HTML parsing libraries, when you pass multiple class names to element selection methods that accept a list of classes, these methods often use
+OR logic. This means they select elements that have ANY of the specified classes, not ALL of them.
                
+
                This behavior is counter intuitive for developers familiar with CSS selectors, where chaining class selectors (like .A.B) means the
+element must have both classes. The OR logic can lead to selecting more elements than intended, causing bugs in data extraction or processing.
                
+
                For example, if you want to find all div elements with both class A and class B, passing both class names as
+separate items in a list to the selection method will actually find all div elements with class A OR class B.
+This includes:
                
+
                  
+  
                • Elements with only class A
                  • 
+  
                • Elements with only class B
                  • 
+  
                • Elements with both classes A and B
                  • 
+
                
+
                When you actually need elements with both classes, this leads to incorrect results.
                
+
                In BeautifulSoup specifically, this occurs when using the class_ parameter with a list of class names in any of these methods. For
+example: soup.find_all('div', class_=['A', 'B']) or soup.find('div', class_=['A', 'B']).
                
+
                What is the potential impact?
                
+
                Using selector methods with collections of criteria when the collection is treated with OR logic but you need AND logic can cause:
                
+
                  
+  
                • Incorrect data extraction: Your code processes elements you didn’t intend to select, leading to wrong or contaminated
+  results.
                  • 
+  
                • Logic errors: Downstream code that expects specific element types may fail or behave unexpectedly.
                  • 
+  
                • Difficult debugging: The issue may not be immediately obvious, especially when testing with markup that happens to contain
+  elements matching your unintended selection criteria.
                  • 
+
                
+
                How to fix it
                
+
                If you need elements that have ALL of the specified classes, replace the class_ parameter list with the select() method
+using chained CSS class selectors. Chain class selectors by placing them directly after each other with a dot prefix (e.g., .A.B).
                
+
                If you actually need elements that have ANY of the specified classes (OR logic), use a comma-separated CSS selector instead (e.g., div.A,
+div.B).
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup(html, 'html.parser')
+# Intending to select divs with both class A AND class B, but actually selects A OR B
+results = soup.find_all('div', class_=['A', 'B'])  # Noncompliant
+
                
+
                Compliant solution
                
+
                When you need elements that have all of the specified classes (AND logic):
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup(html, 'html.parser')
+# Selects divs with both class A AND class B
+results = soup.select('div.A.B')
+
                
+
                When you actually need elements that have any of the specified classes (OR logic), use a comma-separated CSS selector:
                
+
                +from bs4 import BeautifulSoup
+
+soup = BeautifulSoup(html, 'html.parser')
+# Selects divs with class A OR class B
+results = soup.select('div.A, div.B')
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8906.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8906.json
new file mode 100644
index 0000000000..fbff27d05d
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8906.json
@@ -0,0 +1,25 @@
+{
+  "title": "CSS selectors should be used when selecting elements with multiple required classes",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pitfall",
+    "css",
+    "confusing"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8906",
+  "sqKey": "S8906",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8953.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8953.html
new file mode 100644
index 0000000000..6a0fca3442
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8953.html
@@ -0,0 +1,55 @@
+
                This rule raises an issue when both validate_by_alias and validate_by_name are explicitly set to False in a
+Pydantic v2 ConfigDict.
                
+
                Why is this an issue?
                
+
                Data modeling frameworks use configuration options to determine how field values can be provided during object instantiation: one option controls
+whether fields can be populated using alternative names (aliases), and another controls whether they can be populated using their declared attribute
+names. These options control the valid input methods for providing data to the model’s fields.
                
+
                When both options are disabled, the model has no way to accept input data. This creates an invalid configuration that will cause errors when
+describing the model, as there is no valid method to pass values to any field.
                
+
                According to the framework documentation:
                
+
                
+  
                You cannot set both validation options to disable alias-based and name-based population. This would make it impossible to populate an
+  attribute.
                
+
                
+
                This misconfiguration typically occurs when developers are trying to restrict how data is provided to the model, but inadvertently disable all
+input methods.
                
+
                In Pydantic specifically, these configuration options are validate_by_alias and validate_by_name in the model’s
+ConfigDict or Config class.
                
+
                What is the potential impact?
                
+
                When both validation options are disabled, a PydanticUserError is raised at class definition time. This prevents the application from
+starting up correctly and requires the developer to fix the configuration before the model can be used.
                
+
                How to fix it
                
+
                Enable validate_by_name to allow field population using attribute names. This is the most straightforward solution and allows fields
+to be populated using their Python attribute names.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from pydantic import BaseModel, ConfigDict, Field
+
+class Model(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=False,
+        validate_by_name=False  # Noncompliant
+    )
+    my_field: str = Field(alias='my_alias')
+
                
+
                Compliant solution
                
+
                +from pydantic import BaseModel, ConfigDict, Field
+
+class Model(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=False,
+        validate_by_name=True
+    )
+    my_field: str = Field(alias='my_alias')
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8953.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8953.json
new file mode 100644
index 0000000000..73ed615d9a
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8953.json
@@ -0,0 +1,24 @@
+{
+  "title": "Pydantic models should enable either alias or name validation",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pydantic",
+    "pitfall"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8953",
+  "sqKey": "S8953",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8963.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8963.html
new file mode 100644
index 0000000000..f33422477a
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8963.html
@@ -0,0 +1,108 @@
+
                This rule raises an issue when a Pydantic model class inherits from two or more base classes that each define a model_config
+attribute, either directly or through their own inheritance chain. The rule uses the full C3 Method Resolution Order (MRO) when inspecting each direct
+base class. This means it also detects configurations defined in grandparent classes that are inherited through intermediate base classes without
+redefining model_config.
                
+
                Note that the rule checks for the structural presence of model_config in multiple bases and does not compare the actual
+ConfigDict values. Even if two bases currently define identical configurations, the rule still raises an issue. This is intentional:
+identical configurations can diverge independently in future code changes, and Pydantic’s non-MRO merge behavior remains unpredictable regardless of
+whether the values differ at analysis time.
                
+
                Why is this an issue?
                
+
                Pydantic models use the model_config class attribute with a ConfigDict to control validation, serialization, and other
+behaviors.
                
+
                When a Pydantic model inherits from a single base class, configuration inheritance works as expected: the child model inherits the parent’s
+configuration, and any model_config defined on the child overrides the parent’s settings.
                
+
                However, when a model inherits from multiple base classes that each define their own model_config, Pydantic does not
+follow Python’s standard C3 Method Resolution Order (MRO) for merging configurations. Instead, it uses its own internal merging strategy, which means
+you cannot reliably predict which configuration settings will be applied to your model.
                
+
                For example, if Base1 enables a setting that converts string values to lowercase and Base2 enables a setting that
+converts string values to uppercase, and your model inherits from both, the resulting behavior is undefined. The final configuration may use either
+setting, neither, or potentially even raise an error, depending on Pydantic’s internal implementation details.
                
+
                This unpredictability makes the code harder to understand and maintain. Developers reading the code cannot easily determine what configuration will
+be applied without deep knowledge of Pydantic’s internals, and the behavior may change between Pydantic versions.
                
+
                Exceptions
                
+
                The rule does not raise an issue when the model class itself explicitly defines its own model_config. In that case, the developer has
+made the configuration explicit, and Pydantic will use that definition directly, making the resolution predictable.
                
+
                The Pydantic documentation explicitly warns: "If your model inherits from multiple bases, Pydantic currently doesn’t follow the [MRO] for
+configuration merging."
                
+
                What is the potential impact?
                
+
                The unpredictable configuration merging can lead to several problems:
                
+
                  
+  
                • Data validation bugs: String transformations, type coercion, and validation rules may not behave as expected, potentially
+  allowing invalid data to pass validation or rejecting valid data.
                  • 
+  
                • Inconsistent behavior: The same code may behave differently across different framework versions or in different execution
+  contexts.
                  • 
+  
                • Maintenance difficulties: Developers cannot easily understand or predict model behavior without running tests, making the
+  codebase harder to maintain.
                  • 
+  
                • Hidden bugs: Issues may not surface immediately during development but could appear in production when specific data patterns
+  are encountered.
                  • 
+
                
+
                How to fix it
                
+
                Use single inheritance and explicitly define the desired configuration on the final model class. This makes the configuration explicit and
+predictable.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from pydantic import BaseModel, ConfigDict
+
+class Base1(BaseModel):
+    model_config = ConfigDict(str_to_lower=True)
+
+class Base2(BaseModel):
+    model_config = ConfigDict(str_to_upper=True)
+
+class Model(Base1, Base2):  # Noncompliant
+    x: str
+
                
+
                Compliant solution
                
+
                +from pydantic import BaseModel, ConfigDict
+
+class Base1(BaseModel):
+    model_config = ConfigDict(str_to_lower=True)
+
+class Model(Base1):
+    model_config = ConfigDict(str_to_lower=True)
+    x: str
+
                
+
                The rule also flags cases where a model_config is inherited indirectly through an intermediate class. In the example below,
+Intermediate does not define its own model_config, but it inherits one from Base1. Because Model
+inherits from both Intermediate (which carries Base1’s config) and `Base2 (which has its own config), the MRO-based check
+raises an issue. Note that even though both configs are currently identical (frozen=True), the rule still raises an issue because the
+configs can diverge independently in future changes.
                
+
                Noncompliant code example
                
+
                +from pydantic import BaseModel, ConfigDict
+
+class Base1(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+class Base2(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+class Intermediate(Base1):
+    pass
+
+class Model(Intermediate, Base2):  # Noncompliant
+    x: str
+
                
+
                Compliant solution
                
+
                +from pydantic import BaseModel, ConfigDict
+
+class Base1(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+class Intermediate(Base1):
+    pass
+
+class Model(Intermediate):
+    model_config = ConfigDict(frozen=True)
+    x: str
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8963.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8963.json
new file mode 100644
index 0000000000..8da50bbe68
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8963.json
@@ -0,0 +1,25 @@
+{
+  "title": "Pydantic models should not use multiple inheritance with conflicting configurations",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pydantic",
+    "pitfall",
+    "confusing"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8963",
+  "sqKey": "S8963",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8966.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8966.html
new file mode 100644
index 0000000000..f4975352bc
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8966.html
@@ -0,0 +1,65 @@
+
                This rule raises an issue when calling serialization or data conversion functions without specifying a fallback parameter.
                
+
                In Python, this specifically applies to the pydantic_core.to_json(), and pydantic_core.to_jsonable_python()
+functions.
                
+
                Why is this an issue?
                
+
                When serializing data, encountering an unknown or custom type will cause a serialization error if no fallback handler is provided. This happens
+because serialization mechanisms don’t know how to convert types they haven’t been explicitly configured to handle.
                
+
                Without a fallback mechanism, your application will crash at runtime when it attempts to serialize unexpected data. This is particularly
+problematic in production environments where:
                
+
                  
+  
                • Data structures may evolve over time
                  • 
+  
                • Third-party libraries may introduce new types
                  • 
+  
                • User input may contain unexpected custom objects
                  • 
+  
                • Debugging serialization failures becomes difficult
                  • 
+
                
+
                By providing a fallback handler, you create a safety net that prevents crashes and allows your application to handle unknown types gracefully, even
+if the result isn’t perfect.
                
+
                Exceptions
                
+
                Instances of pydantic.BaseModel and its subclasses are natively serializable by pydantic-core, provided their
+model_config does not set arbitrary_types_allowed = True. Calling to_json or to_jsonable_python on
+such objects without a fallback is safe and will not raise a PydanticSerializationError.
                
+
                What is the potential impact?
                
+
                Without a fallback handler, the application will raise an unhandled serialization exception when attempting to serialize unknown types. This leads
+to:
                
+
                  
+  
                • runtime crashes: The application terminates unexpectedly when encountering unsupported types
                  • 
+  
                • poor user experience: Users may lose data or see error messages instead of completed operations
                  • 
+  
                • difficult debugging: Identifying which specific object caused the serialization failure requires examining stack traces
                  • 
+  
                • reduced application resilience: The system becomes fragile and sensitive to data variations
                  • 
+
                
+
                How to fix it
                
+
                Add a fallback parameter to your pydantic-core serialization calls. The fallback function receives the unknown object and should
+return a serializable representation. A simple approach is to convert the object to a string using str().
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from pydantic_core import to_json
+
+class CustomObject:
+    def __init__(self, value):
+        self.value = value
+
+data = {"key": CustomObject(42)}
+result = to_json(data)  # Noncompliant: raises PydanticSerializationError
+
                
+
                Compliant solution
                
+
                +from pydantic_core import to_json
+
+class CustomObject:
+    def __init__(self, value):
+        self.value = value
+
+def handle_unknown(obj):
+    return str(obj)
+
+data = {"key": CustomObject(42)}
+result = to_json(data, fallback=handle_unknown)
+
                
+
                Resources
                
+
                Documentation
                
+
                  
+  
                • Pydantic Documentation - to_json
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8966.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8966.json
new file mode 100644
index 0000000000..0ec5564e95
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8966.json
@@ -0,0 +1,25 @@
+{
+  "title": "pydantic-core serialization calls should provide fallback handlers",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pydantic",
+    "serialization",
+    "pitfall"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8966",
+  "sqKey": "S8966",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "COMPLETE"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8971.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8971.html
new file mode 100644
index 0000000000..521e6d1192
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8971.html
@@ -0,0 +1,67 @@
+
                This rule raises an issue when SkipValidation is used in an Annotated type that also contains validation constraints like
+Field, StringConstraints, or other Pydantic validators.
                
+
                Why is this an issue?
                
+
                In Pydantic, SkipValidation converts a field’s validation schema to any_schema, which accepts any value without type or
+constraint checks. Combining it with validation constraints in the same type annotation leads to broken behavior regardless of ordering:
                
+
                  
+  
                • When SkipValidation is the outermost annotation, it replaces the entire validation schema with any_schema. Any
+  constraints defined in an inner Annotated block are silently dropped — the field accepts any value, including values that violate the
+  constraints.
                  • 
+  
                • When SkipValidation is not the outermost annotation, constraints may still be applied as post-validation functions on top of
+  any_schema. The type check is skipped, so passing a value of the wrong type does not produce a clean ValidationError but
+  instead causes a TypeError at runtime.
                  • 
+
                
+
                This pattern suggests a misunderstanding of how SkipValidation works. Developers likely intended either to validate the data OR to
+skip validation entirely, not both. The presence of both indicates a logic error in the code.
                
+
                For example, in Annotated[Annotated[int, Field(gt=0)], SkipValidation], the Field(gt=0) constraint is completely ignored
+because SkipValidation as the outermost annotation converts the whole schema to any_schema, allowing any value to pass
+through without validation.
                
+
                What is the potential impact?
                
+
                Using SkipValidation alongside validation constraints can lead to security vulnerabilities and data integrity issues:
                
+
                  
+  
                • Invalid data acceptance: Data that should be rejected based on the defined constraints will be accepted without validation
                  • 
+  
                • False security: The code appears to validate input (constraints are visible in the type definition), but actually accepts any
+  data, creating a false sense of security
                  • 
+  
                • Runtime errors: Passing a value of the wrong type bypasses the type check and causes a TypeError instead of a
+  ValidationError, crashing downstream code
                  • 
+  
                • Compliance violations: Applications subject to data validation requirements may unknowingly violate compliance rules
                  • 
+
                
+
                The severity depends on what the data is used for - user input, configuration data, or data from external systems represent higher risk
+scenarios.
                
+
                How to fix it
                
+
                The fix depends on what was intended:
                
+
                  
+  
                • To enforce validation constraints: remove SkipValidation. All constraints will be properly applied.
                  • 
+  
                • To skip validation intentionally: remove the validation constraints and use SkipValidation[Type] on its own. This
+  is appropriate when the data is already validated upstream (for example, passing a previously-constructed model instance), or when the performance
+  cost of re-validation is not worth it and the caller guarantees valid data. The type annotation is still present for IDE and type-checker support —
+  only the runtime validation is skipped.
                  • 
+
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from typing import Annotated
+from pydantic import BaseModel, SkipValidation, Field
+
+class Model(BaseModel):
+    value: Annotated[Annotated[int, Field(gt=0)], SkipValidation]  # Noncompliant - Field(gt=0) is silently ignored
+    other: Annotated[int, SkipValidation, Field(gt=0)]  # Noncompliant - type check is skipped, wrong types cause TypeError
+
                
+
                Compliant solution
                
+
                +from typing import Annotated
+from pydantic import BaseModel, SkipValidation, Field
+
+class Model(BaseModel):
+    validated: Annotated[int, Field(gt=0)]  # constraints properly enforced at runtime
+    trusted: SkipValidation[int]  # validation intentionally skipped; data is already trusted
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8971.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8971.json
new file mode 100644
index 0000000000..9da62989ac
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8971.json
@@ -0,0 +1,26 @@
+{
+  "title": "\"SkipValidation\" should not be combined with validation constraints",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pydantic",
+    "type-hint",
+    "pitfall"
+  ],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-8971",
+  "sqKey": "S8971",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "LOW",
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8973.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8973.html
new file mode 100644
index 0000000000..b800a368a8
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8973.html
@@ -0,0 +1,72 @@
+
                This rule raises an issue when private attributes in data validation or modeling frameworks use a double leading underscore prefix (like
+__attr).
                
+
                In Python, this specifically applies to Pydantic models.
                
+
                Why is this an issue?
                
+
                In data validation frameworks, private attributes are typically defined using a specific naming convention (e.g., prefixing the attribute name with
+a single underscore). These attributes are not validated during object instantiation and are excluded from the schema or type definition.
                
+
                When an attribute is declared with a double leading underscore (e.g., __attr), Python applies name mangling at the class body level,
+renaming the attribute to _ClassName__attr before the framework even sees it. The class will define and instantiate without any error,
+but this creates a silent behavioral trap:
                
+
                  
+  
                • Accessing the attribute from outside the class using the original name (e.g., obj.__attr) raises an AttributeError,
+  because the stored name is _ClassName__attr
                  • 
+  
                • A subclass method referring to self.__attr mangles the name to _SubClass__attr, not _ParentClass__attr,
+  causing an AttributeError at runtime
                  • 
+  
                • The attribute’s default value and configuration still apply, but only under the obscure mangled name, which is an implementation detail not
+  intended to be used directly
                  • 
+
                
+
                This behavior causes subtle bugs that are difficult to detect, because the class appears to be defined correctly and instantiation succeeds without
+any warning.
                
+
                In Pydantic, private attributes must be declared with a single leading underscore (e.g., _private_attr). When an attribute is declared
+with a double leading underscore (e.g., __private_attr), Python’s name mangling silently renames it to
+_ClassName__private_attr before Pydantic processes the class. This causes two concrete problems:
                
+
                  
+  
                • Broken external access: Accessing the attribute from outside the class using the original name (e.g.,
+  model.__private_attr) raises an AttributeError. Only the mangled name model._ClassName__private_attr works,
+  which is an implementation detail callers are not supposed to use.
                  • 
+  
                • Broken subclass access: A subclass method that refers to self.__private_attr will mangle the name to
+  _SubClass__private_attr, not _ParentClass__private_attr, resulting in an AttributeError at runtime.
                  • 
+
                
+
                What is the potential impact?
                
+
                Using a double leading underscore for private attributes in data modeling frameworks leads to:
                
+
                  
+  
                • Runtime errors: Code outside the defining class that attempts to access the attribute using its original name will raise an
+  AttributeError
                  • 
+  
                • Broken inheritance: Subclass methods that reference the attribute will fail because name mangling produces a different key than
+  what the parent class stored
                  • 
+  
                • Obscured intent: The attribute is technically registered but only accessible via the mangled name, which is an implementation
+  detail not part of the intended API
                  • 
+  
                • Maintenance issues: The class definition and instantiation succeed without any error, so the bug only surfaces when the
+  attribute is accessed in a specific context, making it hard to diagnose
                  • 
+
                
+
                How to fix it
                
+
                Replace the double leading underscores with a single underscore prefix. Pydantic recognizes single-underscore attributes as private and initializes
+them correctly.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from pydantic import BaseModel, PrivateAttr
+
+class Model(BaseModel):
+    __counter: int = PrivateAttr(default=0)  # Noncompliant: name mangling prevents expected access
+
+m = Model()
+print(m.__counter)  # Raises AttributeError: 'Model' object has no attribute '__counter'
+
                
+
                Compliant solution
                
+
                +from pydantic import BaseModel, PrivateAttr
+
+class Model(BaseModel):
+    _counter: int = PrivateAttr(default=0)  # Compliant: single underscore prefix
+
+m = Model()
+print(m._counter)  # Works correctly: outputs 0
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8973.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8973.json
new file mode 100644
index 0000000000..969ccfb2a5
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8973.json
@@ -0,0 +1,24 @@
+{
+  "title": "Double leading underscores should not be used for private attributes in Pydantic models",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pydantic",
+    "pitfall"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8973",
+  "sqKey": "S8973",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8974.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8974.html
new file mode 100644
index 0000000000..1dcd169cfb
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8974.html
@@ -0,0 +1,77 @@
+
                This rule raises an issue when a schema type specification parameter is used in a field validation decorator configured to run after type
+conversion, or when the validation timing is not explicitly specified (which defaults to running after conversion).
                
+
                In Python/Pydantic, this specifically refers to using the json_schema_input_type parameter in a @field_validator
+decorator.
                
+
                Why is this an issue?
                
+
                Using an input type schema parameter with an incompatible validation mode will cause the framework to raise a user error when your model is
+defined, preventing your application from starting.
                
+
                In Pydantic specifically, this refers to the @field_validator decorator with its json_schema_input_type parameter. Using
+json_schema_input_type with mode='after' will cause Pydantic to raise a PydanticUserError when your model is
+defined. There is no valid use of json_schema_input_type with mode='after'; this combination always fails at class
+definition time.
                
+
                What is the potential impact?
                
+
                This issue will cause an immediate runtime error when the affected class or type is defined. The application will fail to start, making it
+impossible to use any functionality that depends on the affected type definition.
                
+
                This is a critical bug that will be discovered as soon as the code path defining the type is executed, typically during application startup or when
+the relevant code unit is first loaded.
                
+
                How to fix it
                
+
                If you need to specify json_schema_input_type, change the validator mode to before, plain, or
+wrap:
                
+
                  
+  
                • mode='before' is typically the best choice. The validator runs before Pydantic’s type conversion, so
+  json_schema_input_type correctly describes the raw input type the schema should expect.
                  • 
+  
                • mode='plain' replaces Pydantic’s built-in validation entirely. Use it when the validator handles all type checking itself and
+  Pydantic’s standard conversion should not run.
                  • 
+  
                • mode='wrap' gives the validator control over when Pydantic’s built-in validation runs by receiving a handler argument.
+  Use it when you need to inspect or modify the value both before and after Pydantic’s conversion.
                  • 
+
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from pydantic import BaseModel, field_validator
+
+class Model(BaseModel):
+    a: str
+
+    @field_validator('a', mode='after', json_schema_input_type=str)  # Noncompliant
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
                
+
                Compliant solution
                
+
                +from pydantic import BaseModel, field_validator
+
+class Model(BaseModel):
+    a: str
+
+    @field_validator('a', mode='before', json_schema_input_type=str)
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
                
+
                Pitfalls
                
+
                When switching to mode='wrap', the validator function must accept a second handler argument in addition to the value.
+Using the standard (cls, v) signature with mode='wrap' causes a separate PydanticUserError about an
+unrecognized function signature.
                
+
                +from pydantic import BaseModel, field_validator
+
+class Model(BaseModel):
+    a: str
+
+    # mode='wrap' requires (cls, v, handler), not (cls, v)
+    @field_validator('a', mode='wrap', json_schema_input_type=str)
+    @classmethod
+    def validate_a(cls, v, handler):
+        return handler(v)
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8974.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8974.json
new file mode 100644
index 0000000000..98a0d962d9
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8974.json
@@ -0,0 +1,24 @@
+{
+  "title": "\"json_schema_input_type\" should not be used with \"mode\u003d\u0027after\u0027\" field validators",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pydantic",
+    "pitfall"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8974",
+  "sqKey": "S8974",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8978.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8978.html
new file mode 100644
index 0000000000..19222d6d1e
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8978.html
@@ -0,0 +1,101 @@
+
                This rule raises an issue when a validation model class has fields typed to accept instances of dataclasses, but does not explicitly configure the
+framework’s revalidation behavior for those instances.
                
+
                In Pydantic specifically, this refers to BaseModel classes with fields typed as standard library or Pydantic dataclasses.
                
+
                Why is this an issue?
                
+
                Validation frameworks do not revalidate pre-existing data structure instances by default. When an already-instantiated object is passed as a field
+value, the framework skips validation and accepts it as-is — even if the object was constructed with invalid data. Because lightweight data structures
+such as dataclasses perform no runtime type checking themselves, invalid field values can silently enter a validated model without raising any
+error.
                
+
                Exceptions
                
+
                This rule does not raise an issue when revalidate_instances is explicitly set, regardless of the value. An explicit
+'never' signals that the developer has made a conscious choice to skip revalidation — for example, when dataclass instances are always
+constructed from trusted, pre-validated data.
                
+
                In Pydantic, for example, constructing User(name=['not', 'a', 'string']) succeeds because dataclasses.dataclass does not
+check types at runtime. Passing that instance to a BaseModel field typed as User raises no ValidationError —
+the list is stored silently in place of the expected string.
                
+
                What is the potential impact?
                
+
                Without proper revalidation, your application may process invalid data that should have been rejected. This can lead to:
                
+
                  
+  
                • Runtime errors when code assumes data has been validated
                  • 
+  
                • Incorrect business logic execution due to unexpected data types
                  • 
+  
                • Data corruption if invalid data is persisted to a database
                  • 
+  
                • Security vulnerabilities if validation is used to enforce security constraints
                  • 
+
                
+
                How to fix it
                
+
                There are two ways to address this issue.
                
+
                Option 1: Set revalidate_instances explicitly
                
+
                Explicitly set revalidate_instances on the BaseModel that holds the dataclass field. This can be done with
+ConfigDict or as a class keyword argument.
                
+
                Choose the value that matches your intent:
                
+
                  
+  
                • 'always' — Pydantic revalidates every dataclass instance passed to the model, including ones constructed elsewhere.
                  • 
+  
                • 'subclass-instances' — revalidates only when the instance is of a subclass of the declared field type.
                  • 
+  
                • 'never' — skips revalidation; use this only when dataclass instances are guaranteed to be constructed from trusted, pre-validated
+  data.
                  • 
+
                
+
                Note that enabling revalidate_instances can have a runtime cost, particularly when a model with many nested Pydantic fields holds a
+single dataclass field, since all nested models are also revalidated recursively.
                
+
                Option 2: Replace the dataclass with a Pydantic model
                
+
                Convert the dataclass to a BaseModel (or a Pydantic dataclass). Pydantic models are validated at construction time, so no
+extra revalidation configuration is needed.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import dataclasses
+from pydantic import BaseModel
+
+@dataclasses.dataclass
+class User:
+    name: str
+
+class Foo(BaseModel):  # Noncompliant
+    user: User
+
                
+
                Compliant solution
                
+
                +import dataclasses
+from pydantic import BaseModel, ConfigDict
+
+@dataclasses.dataclass
+class User:
+    name: str
+
+class Foo(BaseModel, revalidate_instances='always'):  # always revalidate
+    user: User
+
+class Bar(BaseModel):  # ConfigDict syntax
+    model_config = ConfigDict(revalidate_instances='always')
+    user: User
+
+class Baz(BaseModel, revalidate_instances='never'):  # explicitly opt out
+    user: User
+
                
+
                Noncompliant code example
                
+
                +import dataclasses
+from pydantic import BaseModel
+
+@dataclasses.dataclass
+class Address:
+    street: str
+
+class Order(BaseModel):  # Noncompliant
+    shipping_address: Address
+
                
+
                Compliant solution
                
+
                +from pydantic import BaseModel
+
+class Address(BaseModel):  # Pydantic model — validated at construction time
+    street: str
+
+class Order(BaseModel):
+    shipping_address: Address
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8978.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8978.json
new file mode 100644
index 0000000000..ab7dba9a47
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8978.json
@@ -0,0 +1,26 @@
+{
+  "title": "Pydantic models with dataclass fields should set \"revalidate_instances\" to \"always\"",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pydantic",
+    "validation",
+    "pitfall"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8978",
+  "sqKey": "S8978",
+  "scope": "Main",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "COMPLETE"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8992.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8992.html
new file mode 100644
index 0000000000..17ac05ece0
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8992.html
@@ -0,0 +1,53 @@
+
                This rule raises an issue when a @pytest.fixture decorator includes both autouse=True and a params argument
+with values.
                
+
                Why is this an issue?
                
+
                Test fixtures serve two important purposes: setting up test prerequisites and providing test data through parametrization. Pytest allows combining
+automatic fixture usage (autouse=True) with fixture parametrization (params=), but the result is discouraged for most test
+suites.
                
+
                When you mark a fixture to run automatically, pytest uses it in every test function within its scope, without requiring the test to explicitly
+request it. This is useful for setup tasks that should always run, like initializing a database connection or configuring logging.
                
+
                Parametrized fixtures use the params argument to provide multiple values. Each test that requests the fixture is executed once for
+each parameter value.
                
+
                When both options are combined, pytest parametrizes every test in scope, even tests that do not reference the fixture, because the autouse fixture
+is injected implicitly. A single test function can therefore run once per parameter value without any visible parametrization on the test itself,
+leading to readability and maintainability issues such as:
                
+
                  
+  
                • Test counts increase unexpectedly; for example, one test with three params values produces three test runs.
                  • 
+  
                • The source of the multiplied tests is not obvious when reading the test function.
                  • 
+  
                • Test selection and debugging become harder because the parametrization is hidden in the autouse fixture.
                  • 
+
                
+
                This pattern is valid pytest syntax, but it makes test behavior harder to understand and maintain. This discouraged combination should never be
+suppressed. Hidden test multiplication from autouse parametrization is always a genuine issue, not an accepted trade-off.
                
+
                What is the potential impact?
                
+
                As test suites grow, hidden autouse parametrization increases CI runtime and makes failures harder to diagnose for developers who are not familiar
+with the fixture graph.
                
+
                How to fix it
                
+
                Remove the params argument if the fixture needs to be automatically used. Use a single, default configuration instead of multiple
+parameter values.
                
+
                If you need multiple setup variants for every test, parametrize the tests themselves with @pytest.mark.parametrize instead of
+parametrizing an autouse fixture. If only some tests need the fixture, drop autouse=True and declare the fixture as a test parameter so
+each test opts in explicitly.
                
+
                Fixtures that use params without autouse=True are valid. This rule flags only the discouraged combination of both
+options.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +@pytest.fixture(autouse=True, params=[1, 2, 3])  # Noncompliant
+def my_fixture():
+    return 'value'
+
                
+
                Compliant solution
                
+
                +@pytest.fixture(autouse=True)
+def my_fixture():
+    return 'value'
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8992.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8992.json
new file mode 100644
index 0000000000..991b0097d1
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8992.json
@@ -0,0 +1,26 @@
+{
+  "title": "Pytest fixtures should not combine \"autouse\" with \"params\"",
+  "type": "BUG",
+  "status": "beta",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pytest",
+    "pitfall",
+    "confusing"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8992",
+  "sqKey": "S8992",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8993.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8993.html
new file mode 100644
index 0000000000..53edc4b12c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8993.html
@@ -0,0 +1,112 @@
+
                This rule raises an issue when a collected test function calls request.getfixturevalue() with a string literal fixture name instead of
+declaring that fixture as a function parameter.
                
+
                In Python’s pytest framework, this specifically refers to the request.getfixturevalue() method.
                
+
                Why is this an issue?
                
+
                In testing frameworks, dependency injection is a powerful mechanism for managing test dependencies and setup code. These frameworks are designed to
+automatically discover and inject dependencies based on function signatures, creating a clear dependency graph.
                
+
                When a test function uses request.getfixturevalue() with a string literal to load a fixture whose name is already known at write time,
+it bypasses the framework’s built-in dependency tracking. This creates several problems:
                
+
                  
+  
                • Hidden dependencies: Other developers (and the framework itself) cannot easily see what dependencies a test requires by looking
+  at its signature
                  • 
+  
                • No static analysis: Tools cannot detect missing or misspelled dependency names until runtime
                  • 
+  
                • Lifecycle management issues: The framework may not properly manage the dependency’s setup and teardown when loaded
+  dynamically
                  • 
+  
                • Reduced maintainability: Refactoring dependencies becomes harder because usage is not explicit
                  • 
+
                
+
                This issue applies when the fixture name is fixed as a string literal in the test. When the name comes from parametrization, configuration, or
+another runtime source, dynamic lookup is intentional and not reported.
                
+
                Dynamic dependency loading with getfixturevalue() remains appropriate inside fixture functions when setup must load another fixture
+conditionally. In collected test functions, dependencies with known names should be declared through the framework’s static declaration mechanism.
                
+
                By declaring known fixture dependencies as parameters, you make your tests more explicit, easier to understand, and better integrated with the
+framework’s dependency management system.
                
+
                In pytest specifically, this anti-pattern manifests when a collected test function calls request.getfixturevalue() with a string
+literal fixture name. When the fixture name is known at write time, declare it as a test parameter so dependencies stay visible to readers and static
+analysis.
                
+
                request.getfixturevalue() remains appropriate inside @pytest.fixture functions for fixture chains, and in tests that
+resolve fixture names from parametrization or configuration when the name is not fixed at write time.
                
+
                Exceptions
                
+
                Fixture chains
                
+
                Using request.getfixturevalue() inside @pytest.fixture functions is acceptable when one fixture must load another
+conditionally.
                
+
                Parametrized fixture-name resolution
                
+
                When the fixture name comes from a variable, for example via @pytest.mark.parametrize, dynamic lookup is intentional and out of scope
+for this rule.
                
+
                conftest.py and hooks
                
+
                Fixture and hook definitions in conftest.py are not collected test functions and are not reported.
                
+
                Plugin and meta tests
                
+
                Tests that exercise pytest plugins or the fixture request API itself may legitimately call getfixturevalue with a runtime name. Review
+manually and suppress only when the test’s purpose requires dynamic fixture resolution.
                
+
                What is the potential impact?
                
+
                Refactoring fixture names leaves no static trace in test signatures, so broken dependencies surface only when tests execute.
                
+
                How to fix it
                
+
                Replace string-literal request.getfixturevalue() calls in test functions with explicit parameter declaration. Convert the call into a
+function parameter with the same name as the fixture being requested.
                
+
                Keep request.getfixturevalue() inside fixture functions when setup must load another fixture conditionally. When a test must exercise
+multiple fixtures from a parametrized name matrix, keep the variable lookup and treat it as an accepted pattern rather than a violation.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.fixture
+def database():
+    class DB:
+        def query(self, sql):
+            return 1
+
+    return DB()
+
+def test_database_query(request):
+    # Noncompliant: known fixture name loaded dynamically
+    db = request.getfixturevalue('database')
+    result = db.query('SELECT 1')
+    assert result == 1
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.fixture
+def database():
+    class DB:
+        def query(self, sql):
+            return 1
+
+    return DB()
+
+def test_database_query(database):
+    # Fixture dependency is now explicit
+    result = database.query('SELECT 1')
+    assert result == 1
+
                
+
                Parametrized fixture-name resolution and fixture chains are acceptable and not reported:
                
+
                +import pytest
+
+@pytest.fixture
+def database():
+    return object()
+
+@pytest.fixture
+def cache():
+    return object()
+
+@pytest.fixture
+def combined(request):
+    # Compliant: fixture-to-fixture lookup
+    return request.getfixturevalue('database')
+
+@pytest.mark.parametrize('fixture_name', ['database', 'cache'])
+def test_matrix(request, fixture_name):
+    # Compliant: fixture name comes from parametrization
+    fixture = request.getfixturevalue(fixture_name)
+    assert fixture is not None
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8993.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8993.json
new file mode 100644
index 0000000000..45ad20b315
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8993.json
@@ -0,0 +1,25 @@
+{
+  "title": "Test functions should declare fixture dependencies as parameters instead of using \"request.getfixturevalue\" with string literals",
+  "type": "CODE_SMELL",
+  "status": "beta",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pytest",
+    "testing",
+    "confusing"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8993",
+  "sqKey": "S8993",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8994.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8994.html
new file mode 100644
index 0000000000..bbeee893e0
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8994.html
@@ -0,0 +1,42 @@
+
                This rule raises an issue when a @pytest.fixture function contains more than one yield statement.
                
+
                Why is this an issue?
                
+
                Pytest yield fixtures separate setup from teardown with a single yield statement. Code before yield runs before the test,
+the yielded value is passed to the test, and code after yield runs during teardown.
                
+
                When a fixture contains more than one yield, pytest accepts the fixture during test setup and runs the test, but raises an error
+during teardown: Failed: fixture function has more than one 'yield'. Any code after the second yield, including cleanup such
+as closing connections, is never executed, which can leave resources open and break test isolation.
                
+
                This rule targets @pytest.fixture setup and teardown patterns only. Ordinary generator functions that use multiple yield
+values outside fixture definitions are out of scope.
                
+
                What is the potential impact?
                
+
                Tests can satisfy their assertions yet still fail during teardown, producing confusing pass-then-fail diagnostics in CI until the fixture is
+corrected.
                
+
                How to fix it
                
+
                Remove the extra yield statements and keep only one. If you need to return multiple values, yield a tuple or other collection. If
+setup differs by condition, compute the value first and yield once on a single code path so teardown always runs afterward.
                
+
                Use return instead of yield when the fixture does not need teardown logic.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +@pytest.fixture
+def database_connection():
+    db = create_connection()
+    yield db  # Noncompliant
+    # Pytest raises "fixture function has more than one 'yield'" at teardown
+    yield db
+    db.close()
+
                
+
                Compliant solution
                
+
                +@pytest.fixture
+def database_connection():
+    db = create_connection()
+    yield db
+    db.close()
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8994.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8994.json
new file mode 100644
index 0000000000..757c8d292b
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8994.json
@@ -0,0 +1,27 @@
+{
+  "title": "Pytest fixtures should contain at most one yield statement",
+  "type": "BUG",
+  "status": "beta",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "tests",
+    "pitfall",
+    "resource-leak",
+    "pytest"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8994",
+  "sqKey": "S8994",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8997.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8997.html
new file mode 100644
index 0000000000..51b7a89934
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8997.html
@@ -0,0 +1,98 @@
+
                This rule raises an issue when test functions manually modify global state such as environment variables, object attributes, or module search paths
+without using test isolation fixtures or mocking utilities provided by the test framework.
                
+
                In Python/pytest, this specifically refers to using the monkeypatch fixture instead of directly modifying sys.path or
+other global state.
                
+
                Why is this an issue?
                
+
                When tests manually modify global state, they risk polluting the test environment for subsequent tests. This happens because the modified state
+persists beyond the test that changed it, unless the test explicitly restores the original values.
                
+
                Manual cleanup has several problems:
                
+
                  
+  
                • Easy to forget: Developers must remember to restore every modification, especially in error cases.
                  • 
+  
                • Exception handling: If a test fails or raises an exception, cleanup code may not execute, leaving the environment in a
+  corrupted state.
                  • 
+  
                • Maintenance burden: Every modification requires corresponding cleanup code, making tests longer and harder to read.
                  • 
+  
                • Incomplete cleanup: Complex objects or nested modifications are difficult to restore correctly.
                  • 
+
                
+
                Test utilities that manage state modifications solve these problems by automatically undoing all modifications when the test completes, regardless
+of whether the test passes or fails. They provide a clean, declarative API that makes the intent clear and eliminates the need for manual cleanup
+code.
                
+
                What is the potential impact?
                
+
                State pollution from missed cleanup propagates across the suite, so failures show up in unrelated tests and erode trust in green CI runs.
                
+
                How to fix it
                
+
                Declare the monkeypatch fixture as a test parameter and use its API instead of manual save/restore logic:
                
+
                  
+  
                • monkeypatch.setenv(name, value) and monkeypatch.delenv(name) for environment variables
                  • 
+  
                • monkeypatch.setattr(target, name, value) and monkeypatch.delattr(target, name) for object attributes, module-level
+  functions, and bound methods
                  • 
+  
                • monkeypatch.setitem(mapping, name, value) and monkeypatch.delitem(mapping, name) for dictionary-like objects
                  • 
+  
                • monkeypatch.syspath_prepend(path) and monkeypatch.chdir(path) for import path and working-directory changes
                  • 
+
                
+
                To replace a function or method, pass the attribute name as a string to monkeypatch.setattr and supply a stub function or
+lambda as the replacement:
                
+
                  
+  
                • monkeypatch.setattr(myapp.api, "fetch", stub_fetch) — replace a module-level function
                  • 
+  
                • monkeypatch.setattr(client, "send", lambda payload: {"status": "ok"}) — replace a method on an object instance
                  • 
+
                
+
                Use a named stub function when the replacement is reused or needs more than one statement; use a lambda for simple one-line return
+values.
                
+
                Each method automatically undoes the modification after the test completes, even when the test fails.
                
+
                For straightforward temporary changes to attributes, environment variables, or callables on existing modules and objects, prefer
+monkeypatch.
                
+
                unittest.mock.patch is a better fit when you need to mock entire modules, assert call arguments with
+Mock.assert_called_with, configure complex side effects, or nest several patches with context managers. Review manually before replacing
+working patch-based code with monkeypatch.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import os
+
+def test_api_key():
+    old_key = os.environ.get('API_KEY')
+    os.environ['API_KEY'] = 'test_key'  # Noncompliant
+
+    result = get_api_configuration()
+    assert result['key'] == 'test_key'
+
+    # Cleanup easily forgotten or skipped on exception
+    if old_key:
+        os.environ['API_KEY'] = old_key
+    else:
+        del os.environ['API_KEY']
+
                
+
                Compliant solution
                
+
                +def test_api_key(monkeypatch):
+    monkeypatch.setenv('API_KEY', 'test_key')
+
+    result = get_api_configuration()
+    assert result['key'] == 'test_key'
+
+    # Automatic cleanup - no manual code needed
+
                
+
                Noncompliant code example
                
+
                +import myapp.config
+
+def test_feature_flag():
+    old_value = myapp.config.ENABLE_FEATURE
+    myapp.config.ENABLE_FEATURE = True  # Noncompliant
+
+    assert myapp.is_feature_enabled()
+
+    myapp.config.ENABLE_FEATURE = old_value
+
                
+
                Compliant solution
                
+
                +def test_feature_flag(monkeypatch):
+    monkeypatch.setattr(myapp.config, 'ENABLE_FEATURE', True)
+
+    assert myapp.is_feature_enabled()
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8997.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8997.json
new file mode 100644
index 0000000000..824203d87b
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8997.json
@@ -0,0 +1,24 @@
+{
+  "title": "Tests should use the \"monkeypatch\" fixture for temporary modifications",
+  "type": "CODE_SMELL",
+  "status": "beta",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pytest",
+    "testing"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8997",
+  "sqKey": "S8997",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "COMPLETE"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8998.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8998.html
new file mode 100644
index 0000000000..af7d46dca2
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8998.html
@@ -0,0 +1,61 @@
+
                This rule raises an issue when a test parameterization mechanism is configured with an empty collection as the source of test values.
                
+
                In Python with pytest, this specifically occurs when using the @pytest.mark.parametrize decorator with an empty sequence (list, tuple,
+or other iterable) as the values argument.
                
+
                Why is this an issue?
                
+
                Passing an empty list to @pytest.mark.parametrize collects the test but skips it with got empty parameter set for (…​).
+The suite still passes while providing no coverage for that function.
                
+
                When @pytest.mark.parametrize has no value sets to iterate over, the test is silently skipped during collection:
                
+
                  
+  
                • Your test suite appears to pass, but this test isn’t actually running
                  • 
+  
                • You have no test coverage for the function being tested
                  • 
+  
                • Bugs in your code may go undetected
                  • 
+
                
+
                This situation typically occurs due to:
                
+
                  
+  
                • Accidentally deleting or commenting out all test cases
                  • 
+  
                • Incomplete test implementation (test structure created but cases not yet added)
                  • 
+  
                • Copy-paste errors when creating new tests
                  • 
+  
                • Refactoring mistakes where test cases were moved or removed
                  • 
+
                
+
                Unlike mistakes that cause failures, an empty parametrized test collection fails silently. The test won’t raise an error — it simply won’t run,
+which makes the problem easy to miss until you discover missing coverage.
                
+
                An empty parameter list is never a valid end state for a committed test. Suppressing this issue is not appropriate, as the test will not run until
+values are provided.
                
+
                What is the potential impact?
                
+
                Regressions can go undetected when tests are skipped silently without failing the build.
                
+
                How to fix it
                
+
                Add at least one case tuple to the @pytest.mark.parametrize values list so the test body actually runs.
                
+
                If the test is not ready yet, do not simply remove the decorator while keeping its parameters: pytest will treat those names as fixtures and fail
+at setup with fixture '…​' not found. Instead, either add the missing cases, rewrite the test without parametrization (inline the values
+in the function body), or mark the test explicitly with @pytest.mark.skip(reason="…​") on a parameterless function.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.mark.parametrize('operand,expected', [])
+def test_double(operand, expected):
+    assert double(operand) == expected  # Noncompliant
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.mark.parametrize('operand,expected', [
+    (1, 2),
+    (2, 4),
+    (3, 6),
+    (0, 0),
+])
+def test_double(operand, expected):
+    assert double(operand) == expected
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8998.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8998.json
new file mode 100644
index 0000000000..eeaa4fd477
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8998.json
@@ -0,0 +1,26 @@
+{
+  "title": "Parametrize decorators should not have empty parameter lists",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pytest",
+    "tests",
+    "pitfall"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8998",
+  "sqKey": "S8998",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8999.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8999.html
new file mode 100644
index 0000000000..b89a52430c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8999.html
@@ -0,0 +1,44 @@
+
                This rule raises an issue when the plugin configuration variable is defined in a regular test file (any file other than the designated
+configuration file).
                
+
                Why is this an issue?
                
+
                pytest_plugins in conftest.py loads before test collection, so plugins are available for early hooks such as
+pytest_addoption. In test modules, plugins load only when that module is imported during collection, which can change behavior under
+parallel CI.
                
+
                Pytest deduplicates plugins by name, so declaring the same plugin in multiple test modules does not load it twice. The risk is late registration
+and collection-order dependence, not duplicate initialization.
                
+
                This rule flags any pytest_plugins assignment outside conftest.py.
                
+
                What is the potential impact?
                
+
                Misplaced plugin declarations make load order depend on collection sequence, so the same suite can pass locally and fail under parallel or sharded
+CI.
                
+
                How to fix it
                
+
                Move pytest_plugins from test modules to conftest.py in the same directory or a parent directory.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +# test_something.py
+pytest_plugins = ['pytest_cov', 'pytest_timeout']  # Noncompliant
+
+def test_feature():
+    assert True
+
                
+
                Compliant solution
                
+
                +# conftest.py
+pytest_plugins = ['pytest_cov', 'pytest_timeout']
+
+# test_something.py
+def test_feature():
+    assert True
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8999.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8999.json
new file mode 100644
index 0000000000..ed7969e89f
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S8999.json
@@ -0,0 +1,27 @@
+{
+  "title": "\"pytest_plugins\" should be defined in conftest.py files",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "test",
+    "confusing",
+    "pitfall",
+    "pytest"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-8999",
+  "sqKey": "S8999",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9000.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9000.html
new file mode 100644
index 0000000000..1770117899
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9000.html
@@ -0,0 +1,112 @@
+
                This rule raises an issue when pytest.raises() is called without a with statement, including standalone calls, the
+deprecated callable-passing form, and typos that call the function before entering the context manager.
                
+
                In Python, this refers to the different usages of pytest.raises() without a with statement, such as:
                
+
                  
+  
                • Standalone calls such as pytest.raises(ValueError) that never wrap the code under test
                  • 
+  
                • The deprecated form pytest.raises(ExpectedError, func, *args, **kwargs) that passes a callable and its arguments
                  • 
+  
                • The typo pytest.raises(ExpectedError, func(*args, **kwargs)) that calls the function immediately and silently skips verification
+  when no exception is raised
                  • 
+
                
+
                Why is this an issue?
                
+
                Pytest cannot verify the outcome if the code under test is not wrapped in a with pytest.raises(…​): block.
                
+
                Standalone calls
                
+
                pytest.raises(ValueError) without with constructs a context manager and discards it. The test passes even when the
+following code does not raise:
                
+
                +def test_invalid_input():
+    pytest.raises(ValueError)
+    process_data('hello')  # No exception — test still passes
+
                
+
                Deprecated callable-passing form
                
+
                Pytest still supports passing the callable and its arguments:
                
+
                +pytest.raises(ValueError, bootstrap_session, df=-1)  # Deprecated
+
                
+
                This executes bootstrap_session(df=-1) and fails when no exception is raised. It works, but pytest deprecates it. Refactoring this
+form into a bare standalone call silently stops verifying exceptions.
                
+
                Typo: calling the function immediately
                
+
                A common mistake adds parentheses around the call:
                
+
                +pytest.raises(NotImplementedError, bootstrap_session(df=10))  # Silent failure
+
                
+
                Here bootstrap_session runs before pytest.raises is entered. When df=10 is valid and no exception is raised,
+pytest.raises receives the return value and the test passes without verifying anything.
                
+
                Correct usage
                
+
                +with pytest.raises(ValueError):
+    bootstrap_session(df=-1)
+
                
+
                The with block must raise the expected exception, or the test fails.
                
+
                What is the potential impact?
                
+
                Tests that never enter the pytest.raises context manager can pass when no exception is raised, leaving error-handling regressions
+undetected. Deprecated callable-passing syntax and the parenthesis typo are prone to silent breakage during refactors.
                
+
                How to fix it
                
+
                In Python with pytest, use with pytest.raises(ValueError): around the code that should fail.
                
+
                Wrap the code that should raise with with pytest.raises(ExpectedError):. To inspect the exception, use as exc_info or the
+match parameter.
                
+
                Migrate deprecated callable-passing calls by moving the invocation into the with block.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+def process_data(data):
+    return data.upper()
+
+def test_invalid_input():
+    pytest.raises(ValueError)  # Noncompliant: context manager never entered
+    process_data('hello')
+
                
+
                Compliant solution
                
+
                +import pytest
+
+def process_data(data):
+    return data.upper()
+
+def test_invalid_input():
+    with pytest.raises(ValueError):
+        process_data('hello')
+
                
+
                Noncompliant code example
                
+
                +import pytest
+
+def bootstrap_session(df=10):
+    if df <= 0:
+        raise ValueError('df must be positive')
+    if df > 20:
+        raise NotImplementedError('df > 20 not supported')
+
+def test_invalid_df():
+    pytest.raises(ValueError, bootstrap_session, df=-1)  # Noncompliant: deprecated form
+
+def test_unsupported_df():
+    pytest.raises(NotImplementedError, bootstrap_session(df=10))  # Noncompliant: function called immediately
+
                
+
                Compliant solution
                
+
                +import pytest
+
+def bootstrap_session(df=10):
+    if df <= 0:
+        raise ValueError('df must be positive')
+    if df > 20:
+        raise NotImplementedError('df > 20 not supported')
+
+def test_invalid_df():
+    with pytest.raises(ValueError):
+        bootstrap_session(df=-1)
+
+def test_unsupported_df():
+    with pytest.raises(NotImplementedError):
+        bootstrap_session(df=25)
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9000.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9000.json
new file mode 100644
index 0000000000..97950b4530
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9000.json
@@ -0,0 +1,25 @@
+{
+  "title": "\"pytest.raises\" should be used as a context manager",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9000",
+  "sqKey": "S9000",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9001.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9001.html
new file mode 100644
index 0000000000..3ddf54095b
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9001.html
@@ -0,0 +1,32 @@
+
                This rule raises an issue when @pytest.mark.xfail is used without a reason parameter.
                
+
                Why is this an issue?
                
+
                When writing tests, @pytest.mark.xfail marks a test as expected to fail, for example while a known bug remains unfixed.
                
+
                @pytest.mark.xfail without reason leaves future maintainers without context for why the failure is expected. The
+reason must appear on the decorator; comments or docstrings do not satisfy this rule.
                
+
                What is the potential impact?
                
+
                Undocumented expected failures accumulate as the codebase changes, so teams cannot tell which markers still reflect real defects.
                
+
                How to fix it
                
+
                Add the reason parameter with a concise explanation or issue reference.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +@pytest.mark.xfail  # Noncompliant
+def test_division_by_zero():
+    result = divide(10, 0)
+    assert result is None
+
                
+
                Compliant solution
                
+
                +@pytest.mark.xfail(reason='Issue #456: divide() should raise ValueError for zero divisor')
+def test_division_by_zero():
+    result = divide(10, 0)
+    assert result is None
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9001.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9001.json
new file mode 100644
index 0000000000..96a18ba42f
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9001.json
@@ -0,0 +1,24 @@
+{
+  "title": "Expected test failures should provide a reason",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9001",
+  "sqKey": "S9001",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9002.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9002.html
new file mode 100644
index 0000000000..4571ca839a
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9002.html
@@ -0,0 +1,36 @@
+
                This rule raises an issue when a function-scoped test uses the tmp_path_factory fixture instead of the tmp_path
+fixture.
                
+
                Why is this an issue?
                
+
                tmp_path provides an isolated directory for one test. tmp_path_factory is for session, module, or class-scoped fixtures
+that share directories across tests.
                
+
                Using the factory in a function-scoped test adds an unnecessary mktemp() call and obscures intent.
                
+
                What is the potential impact?
                
+
                Choosing the session-scoped factory in function-scoped tests raises the cost of onboarding developers to the fixture graph.
                
+
                How to fix it
                
+
                Replace tmp_path_factory with tmp_path in function-scoped tests.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +def test_file_operation(tmp_path_factory):  # Noncompliant
+    # Unnecessary factory for function scope
+    temp_dir = tmp_path_factory.mktemp('data')
+    test_file = temp_dir / 'test.txt'
+    test_file.write_text('content')
+    assert test_file.read_text() == 'content'
+
                
+
                Compliant solution
                
+
                +def test_file_operation(tmp_path):
+    # Direct tmp_path for function scope
+    test_file = tmp_path / 'test.txt'
+    test_file.write_text('content')
+    assert test_file.read_text() == 'content'
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9002.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9002.json
new file mode 100644
index 0000000000..6e57664a5a
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9002.json
@@ -0,0 +1,25 @@
+{
+  "title": "Function-scoped tests should use \"tmp_path\" instead of \"tmp_path_factory\"",
+  "type": "CODE_SMELL",
+  "status": "beta",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "pytest",
+    "tests",
+    "confusing"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9002",
+  "sqKey": "S9002",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9073.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9073.html
new file mode 100644
index 0000000000..af2d01275a
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9073.html
@@ -0,0 +1,80 @@
+
                This rule raises an issue when a test assertion combines multiple independent conditions with and, or when it asserts the negation of
+an or expression (assert not (a or b)).
                
+
                It does not raise an issue on plain assert a or b, because splitting that form would change the meaning from "at least one condition
+holds" to "all conditions hold".
                
+
                Why is this an issue?
                
+
                Composite assertions hide which condition failed. When several checks are joined in a single assert, a failure reports the whole
+expression as false instead of pointing at the specific condition that broke.
                
+
                Assertions joined with and
                
+
                assert a and b verifies two independent facts in one statement. If the assertion fails, the message does not clearly identify whether
+a, b, or both were false:
                
+
                +def test_user(user):
+    assert user.is_active and user.is_verified  # Which condition failed?
+
                
+
                Splitting into separate asserts makes each failure actionable:
                
+
                +def test_user(user):
+    assert user.is_active
+    assert user.is_verified
+
                
+
                Negated or expressions
                
+
                assert not (a or b) is equivalent to asserting that both a and b are false (De Morgan’s law). It has the
+same opacity problem as an and chain:
                
+
                +def test_axis_hidden(axis):
+    assert not (axis.visible or axis.label_visible)  # Which flag is still true?
+
                
+
                Split it into independent negated asserts:
                
+
                +def test_axis_hidden(axis):
+    assert not axis.visible
+    assert not axis.label_visible
+
                
+
                Why plain or is excluded
                
+
                assert a or b means at least one condition must hold. Replacing it with two separate asserts would require both to hold and would
+change the test’s intent. This rule therefore does not flag that form.
                
+
                What is the potential impact?
                
+
                When a composite assertion fails, developers spend extra time deciphering which condition broke. Opaque failure messages slow down debugging and
+make flaky or partial regressions harder to diagnose. Splitting assertions keeps each check independent and produces clearer failure reports.
                
+
                How to fix it
                
+
                Split composite assertions into separate assert statements, one per independent condition. For assert not (a or b), use
+De Morgan’s law and write assert not a and assert not b.
                
+
                This applies to:
                
+
                  
+  
                • assert a and b (and longer and chains) that combine independent conditions
                  • 
+  
                • assert not (a or b) (De Morgan-equivalent negation of an or expression)
                  • 
+
                
+
                Plain assert a or b is not flagged, because splitting it would change the meaning of the test.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +def test_user(user):
+    assert user.is_active and user.is_verified  # Noncompliant
+
                
+
                Compliant solution
                
+
                +def test_user(user):
+    assert user.is_active
+    assert user.is_verified
+
                
+
                Noncompliant code example
                
+
                +def test_axis_hidden(axis):
+    assert not (axis.visible or axis.label_visible)  # Noncompliant
+
                
+
                Compliant solution
                
+
                +def test_axis_hidden(axis):
+    assert not axis.visible
+    assert not axis.label_visible
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9073.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9073.json
new file mode 100644
index 0000000000..39c697626f
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9073.json
@@ -0,0 +1,23 @@
+{
+  "title": "Composite assertions should be split",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9073",
+  "sqKey": "S9073",
+  "scope": "Main",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  },
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9074.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9074.html
new file mode 100644
index 0000000000..d70228b57b
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9074.html
@@ -0,0 +1,99 @@
+
                This rule raises an issue when a pytest mark is applied where it has no effect: any @pytest.mark.* on a @pytest.fixture,
+or @pytest.mark.usefixtures() with no fixture names.
                
+
                Why is this an issue?
                
+
                Pytest applies marks to tests, classes, and modules. Marks on fixtures are ignored, and an empty @pytest.mark.usefixtures() does
+nothing.
                
+
                Marks on fixtures
                
+
                Decorating a fixture with @pytest.mark.asyncio, @pytest.mark.usefixtures(…​), or any other @pytest.mark.*
+does not change how the fixture runs or which tests use it:
                
+
                +@pytest.mark.asyncio  # Ignored: fixtures are not tests
+@pytest.fixture
+async def db():
+    return await connect()
+
+@pytest.mark.usefixtures("db")  # Ignored on fixtures
+@pytest.fixture
+def client(db):
+    return Client(db)
+
+@pytest.mark.slow  # Ignored on fixtures
+@pytest.fixture
+def cache():
+    return {}
+
                
+
                Maintainers may assume the mark selects the fixture, runs it asynchronously, or injects other fixtures. None of that happens.
                
+
                To depend on another fixture, declare it as a parameter. For async fixtures, use an async fixture function; pytest-asyncio does not require
+@pytest.mark.asyncio on the fixture itself.
                
+
                Empty usefixtures
                
+
                @pytest.mark.usefixtures() with no names is a no-op:
                
+
                +@pytest.mark.usefixtures()  # No fixtures requested
+def test_ping():
+    assert ping() == "pong"
+
                
+
                Either pass the fixture names that should be activated, or remove the decorator.
                
+
                What is the potential impact?
                
+
                Useless marks look intentional but change nothing. Teams may believe fixtures are skipped, marked slow, run under asyncio, or wired via
+usefixtures, while the suite behaves differently than expected.
                
+
                How to fix it
                
+
                Remove marks from fixtures. Request other fixtures as parameters instead of @pytest.mark.usefixtures on the fixture. For empty
+@pytest.mark.usefixtures(), either supply fixture names or delete the decorator.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.mark.asyncio  # Noncompliant
+@pytest.fixture
+async def db():
+    return await connect()
+
+@pytest.mark.usefixtures("db")  # Noncompliant
+@pytest.fixture
+def client(db):
+    return Client(db)
+
+@pytest.mark.slow  # Noncompliant
+@pytest.fixture
+def cache():
+    return {}
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.fixture
+async def db():
+    return await connect()
+
+@pytest.fixture
+def client(db):
+    return Client(db)
+
+@pytest.fixture
+def cache():
+    return {}
+
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.mark.usefixtures()  # Noncompliant
+def test_ping():
+    assert ping() == "pong"
+
                
+
                Compliant solution
                
+
                +def test_ping():
+    assert ping() == "pong"
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9074.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9074.json
new file mode 100644
index 0000000000..f12403cfff
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9074.json
@@ -0,0 +1,24 @@
+{
+  "title": "Pytest marks and usefixtures should not be applied uselessly",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9074",
+  "sqKey": "S9074",
+  "scope": "Tests",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  },
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9075.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9075.html
new file mode 100644
index 0000000000..42b8d5075c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9075.html
@@ -0,0 +1,85 @@
+
                This is an issue when test code verifies that a warning was emitted without specifying its type and without checking its message, or when it uses
+the overly broad base Warning type without checking the message.
                
+
                In Python with pytest, this refers to underspecified pytest.warns() usage, such as:
                
+
                  
+  
                • Calls without an expected warning type and without match=, for example pytest.warns()
                  • 
+  
                • The base type Warning without a match parameter
                  • 
+
                
+
                More specific warning types such as UserWarning or DeprecationWarning are not covered by this rule when used without
+match=.
                
+
                Omitting the warning type while providing an effective match= is not an issue, because pytest.warns defaults to
+Warning and the message pattern narrows the expectation.
                
+
                Why is this an issue?
                
+
                When testing that code emits a warning, it is not sufficient to verify only that some warning was raised. Tests should also validate the
+warning type or message to differentiate expected warnings from unexpected ones.
                
+
                Consider a function that should emit a DeprecationWarning when given a legacy argument. If your test only checks that a warning
+occurred, it cannot distinguish between:
                
+
                  
+  
                • The expected DeprecationWarning indicating proper deprecation signaling
                  • 
+  
                • An unexpected UserWarning from a different code path
                  • 
+  
                • An unexpected ResourceWarning from a resource leak
                  • 
+
                
+
                All three scenarios would make the test pass, even though two represent unintended behavior.
                
+
                In pytest, the following patterns lead to insufficiently specific warning testing:
                
+
                  
+  
                • Using pytest.warns() without an expected warning type and without match=
                  • 
+  
                • Using pytest.warns(Warning) without match=
                  • 
+
                
+
                The base Warning class is the root of the warning hierarchy and catches every warning subtype. More specific types such as
+UserWarning or DeprecationWarning are accepted without match=.
                
+
                Omitting the warning type while providing match= is accepted: pytest.warns defaults to Warning, and the
+message pattern already narrows the expectation.
                
+
                These patterns create fragile tests that may pass for the wrong reasons, allowing regressions to slip through undetected.
                
+
                What is the potential impact?
                
+
                Tests that underspecify expected warnings can pass when an unrelated warning is emitted, leaving regressions undetected. Narrowing the expected
+type and message keeps warning tests as a reliable safety net.
                
+
                How to fix it
                
+
                Pass a specific warning type to pytest.warns. When using the base Warning type (explicitly or via the default), add
+match= with a pattern for the message.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import warnings
+import pytest
+
+def test_warns_without_type():
+    with pytest.warns():  # Noncompliant: no expected warning type
+        warnings.warn("x", UserWarning)
+
+def test_warns_broad_type():
+    with pytest.warns(Warning):  # Noncompliant: base Warning without match=
+        warnings.warn("deprecated", DeprecationWarning)
+
                
+
                Compliant solution
                
+
                +import warnings
+import pytest
+
+def test_warns_without_type():
+    with pytest.warns(UserWarning):
+        warnings.warn("x", UserWarning)
+
+def test_warns_broad_type():
+    # Base Warning is allowed when match= narrows the expected message
+    with pytest.warns(Warning, match="deprecated"):
+        warnings.warn("deprecated", DeprecationWarning)
+
+def test_warns_match_only():
+    # Omitting the type is allowed when match= is provided
+    with pytest.warns(match="deprecated"):
+        warnings.warn("deprecated", DeprecationWarning)
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S5958} - Tests should check which exception is thrown
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9075.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9075.json
new file mode 100644
index 0000000000..c283feaca2
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9075.json
@@ -0,0 +1,24 @@
+{
+  "title": "Tests should check which warning is expected",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9075",
+  "sqKey": "S9075",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "TESTED"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9076.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9076.html
new file mode 100644
index 0000000000..118700104d
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9076.html
@@ -0,0 +1,50 @@
+
                This rule raises an issue when a pytest fixture uses the deprecated @pytest.yield_fixture decorator.
                
+
                Why is this an issue?
                
+
                Before pytest 3.0, fixtures that needed teardown used @pytest.yield_fixture. Since then, @pytest.fixture supports
+yield for setup and teardown. pytest.yield_fixture remains only as a deprecated alias:
                
+
                +@pytest.yield_fixture  # Deprecated
+def resource():
+    value = acquire()
+    yield value
+    release(value)
+
                
+
                Replace it with @pytest.fixture; the yield body stays the same.
                
+
                What is the potential impact?
                
+
                Deprecated @pytest.yield_fixture triggers deprecation warnings and will break on newer pytest versions. Migrating to
+@pytest.fixture keeps fixture code compatible and consistent with current pytest APIs.
                
+
                How to fix it
                
+
                Replace @pytest.yield_fixture with @pytest.fixture. Keep the same yield body for setup and teardown.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.yield_fixture  # Noncompliant
+def old_style():
+    value = 1
+    yield value
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.fixture
+def old_style():
+    value = 1
+    yield value
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S9116} - Pytest fixture options should be passed as keyword arguments
                  • 
+  
                • {rule:python:S9117} - Pytest fixtures should not declare the default scope="function"
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9076.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9076.json
new file mode 100644
index 0000000000..22aa5154a3
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9076.json
@@ -0,0 +1,24 @@
+{
+  "title": "Deprecated pytest.yield_fixture should be replaced with pytest.fixture",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9076",
+  "sqKey": "S9076",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9077.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9077.html
new file mode 100644
index 0000000000..f3b45a9d2c
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9077.html
@@ -0,0 +1,54 @@
+
                This rule raises an issue when a test intentionally aborts with assert False, assert 0, or a pytest.fail()
+call that has no failure message.
                
+
                In Python with pytest, this covers:
                
+
                  
+  
                • assert False or assert 0 used as an intentional abort
                  • 
+  
                • pytest.fail() called without a non-empty message (including empty string and empty reason)
                  • 
+
                
+
                Why is this an issue?
                
+
                Tests sometimes need to fail on purpose: a feature is not ready, a dependency is blocked, or a branch of the test should never succeed.
                
+
                assert False and assert 0 look like accidental logic bugs rather than deliberate aborts. Readers cannot tell whether the
+author meant to stop the test or left a broken condition behind.
                
+
                pytest.fail() without a message fails the test but leaves no explanation in the report, so maintainers cannot triage the failure
+without digging through history or comments.
                
+
                pytest.fail("…​") states the intent and records why the test stopped.
                
+
                What is the potential impact?
                
+
                Intentional failures without a clear signal or message are harder to triage. Teams may waste time treating deliberate aborts as real assertion
+bugs, or overlook why a test is blocked.
                
+
                How to fix it
                
+
                Replace assert False / assert 0 with pytest.fail("…​"), and always pass a concise message (or
+reason=) that explains why the test fails.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+def test_not_ready():
+    assert False  # Noncompliant
+
+def test_blocked():
+    pytest.fail()  # Noncompliant
+
                
+
                Compliant solution
                
+
                +import pytest
+
+def test_not_ready():
+    pytest.fail("feature not implemented yet")
+
+def test_blocked():
+    pytest.fail("blocked on issue 42")
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S5914} - Assertions should not fail or succeed unconditionally
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9077.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9077.json
new file mode 100644
index 0000000000..fe55e21f83
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9077.json
@@ -0,0 +1,24 @@
+{
+  "title": "Intentional test failures should use pytest.fail with a message",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9077",
+  "sqKey": "S9077",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9078.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9078.html
new file mode 100644
index 0000000000..9244fc15fd
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9078.html
@@ -0,0 +1,74 @@
+
                This rule raises an issue when the argvalues collection of a @pytest.mark.parametrize decorator contains duplicate test
+cases.
                
+
                In Python with pytest, this occurs when @pytest.mark.parametrize is given an argvalues sequence that repeats the same
+case more than once (for example duplicate literals, names, or calls).
                
+
                Why is this an issue?
                
+
                @pytest.mark.parametrize runs the decorated test once for each entry in its values collection. Duplicate cases therefore execute the
+same scenario more than once.
                
+
                That wastes CI time and usually signals a copy-paste mistake: an intended distinct case was never updated, so coverage looks broader than it
+is.
                
+
                Duplicates are detected by comparing the parametrize entries as expressions (literals, names, calls, and other AST forms), not only literal values.
+Accidental duplicates should be removed. Rarely, repeated identical entries are intentional when each run exercises mutable shared state; keep those
+only when that is deliberate.
                
+
                This rule complements {rule:python:S8998}, which flags empty parametrize value lists.
                
+
                What is the potential impact?
                
+
                Duplicate cases inflate suite runtime and can hide unfinished copy-paste edits. Teams may believe a scenario is covered in several ways when the
+same inputs are simply repeated.
                
+
                How to fix it
                
+
                When the duplicate is accidental, remove the repeated entries from the @pytest.mark.parametrize values list so each case appears only
+once. If the repeated entry was meant to be a different scenario, replace it with the intended distinct inputs.
                
+
                Do not remove duplicates that are intentional for stateful behavior (for example repeated invocations that observe mutable global state). In those
+cases, keep the repeated cases or make the shared-state dependency explicit another way.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.mark.parametrize("n", [1, 2, 2, 3])  # Noncompliant
+def test_double(n):
+    assert double(n) == n * 2
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.mark.parametrize("n", [1, 2, 3])
+def test_double(n):
+    assert double(n) == n * 2
+
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.mark.parametrize("operand,expected", [
+    (1, 2),
+    (2, 4),
+    (1, 2),  # Noncompliant
+    (3, 6),
+])
+def test_double(operand, expected):
+    assert double(operand) == expected
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.mark.parametrize("operand,expected", [
+    (1, 2),
+    (2, 4),
+    (3, 6),
+])
+def test_double(operand, expected):
+    assert double(operand) == expected
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9078.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9078.json
new file mode 100644
index 0000000000..b46be08c89
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9078.json
@@ -0,0 +1,24 @@
+{
+  "title": "Parametrize decorators should not contain duplicate test cases",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9078",
+  "sqKey": "S9078",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "EFFICIENT"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9080.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9080.html
new file mode 100644
index 0000000000..ec8a38e8e3
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9080.html
@@ -0,0 +1,68 @@
+
                This rule raises an issue when a @pytest.fixture uses request.addfinalizer(…​) for teardown instead of a yield
+fixture.
                
+
                In Python, this refers to fixtures that call request.addfinalizer(…​) and return a resource instead of yielding it and running
+teardown after the yield.
                
+
                Why is this an issue?
                
+
                Pytest fixtures can clean up either with a sequential yield (setup before yield, teardown after) or with callback-based
+request.addfinalizer(…​). The sequential style is clearer for ordinary fixtures: setup, provide the value, then tear down in one linear
+flow.
                
+
                Registering teardown with request.addfinalizer while returning the resource scatters setup and cleanup:
                
+
                +@pytest.fixture
+def with_finalizer(request):
+    resource = open_resource()
+    request.addfinalizer(resource.close)
+    return resource
+
                
+
                Prefer yielding the resource and running cleanup after the test:
                
+
                +@pytest.fixture
+def with_finalizer():
+    resource = open_resource()
+    yield resource
+    resource.close()
+
                
+
                request.addfinalizer remains appropriate for the factory-as-fixture pattern, where teardown must be registered inside a nested factory
+that creates resources on demand.
                
+
                What is the potential impact?
                
+
                addfinalizer-based teardown is harder to follow than a linear yield fixture, which slows reviews and increases the chance of
+mismatched setup and cleanup.
                
+
                How to fix it
                
+
                Replace request.addfinalizer teardown with a yield fixture: yield the resource, then run cleanup after the test.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.fixture
+def with_finalizer(request):
+    resource = open_resource()
+    request.addfinalizer(resource.close)  # Noncompliant
+    return resource
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.fixture
+def with_finalizer():
+    resource = open_resource()
+    yield resource
+    resource.close()
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S8994} - Fixtures should not contain more than one yield
                  • 
+  
                • {rule:python:S9100} - Pytest fixtures without teardown should use return instead of yield
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9080.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9080.json
new file mode 100644
index 0000000000..26bf2850fa
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9080.json
@@ -0,0 +1,24 @@
+{
+  "title": "Pytest fixtures should use yield for teardown",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9080",
+  "sqKey": "S9080",
+  "scope": "Tests",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CONVENTIONAL"
+  },
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9081.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9081.html
new file mode 100644
index 0000000000..bda3ef4601
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9081.html
@@ -0,0 +1,78 @@
+
                This rule raises an issue when unittest.mock.patch (or a pytest-mock mocker.patch call) is given a lambda
+whose body only returns a value and does not use its parameters.
                
+
                In Python, this refers to calls such as:
                
+
                  
+  
                • unittest.mock.patch("target", lambda: value) or patch("target", lambda *args: value) when the lambda body does not use
+  its parameters
                  • 
+  
                • Equivalent mocker.patch(...) / session_mocker.patch(...) calls from pytest-mock
                  • 
+
                
+
                Why is this an issue?
                
+
                When writing tests, patch and mocker.patch often stub a dependency so the code under test receives a fixed value.
                
+
                Passing a lambda that only returns a constant is less clear than return_value=. The lambda adds an unnecessary callable,
+and the mock no longer supports the usual assertions such as assert_called_once_with. return_value= also stays valid if the
+patched function’s signature changes.
                
+
                Patching with a lambda that only returns a value
                
+
                +with patch("app.api.fetch", lambda: {"ok": True}):
+    assert call_api()["ok"]
+
                
+
                The lambda never uses its arguments; it only supplies a return value.
                
+
                Prefer return_value
                
+
                +with patch("app.api.fetch", return_value={"ok": True}):
+    assert call_api()["ok"]
+
                
+
                return_value= states the intent directly and keeps the mock usable for call assertions.
                
+
                This rule does not raise when the lambda uses its parameters, because that expresses custom behavior rather than a constant stub.
                
+
                What is the potential impact?
                
+
                Lambda-only stubs obscure intent and block standard mock assertions. Tests become harder to maintain when signatures change or when call arguments
+need verification.
                
+
                How to fix it
                
+
                Replace the lambda with return_value= set to the same constant. Keep a lambda (or side_effect) only when the stub must
+use call arguments or run custom logic.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from unittest.mock import patch
+
+def call_api():
+    from app.api import fetch
+    return fetch()
+
+def test_call_api_ok():
+    with patch("app.api.fetch", lambda: {"ok": True}):  # Noncompliant
+        assert call_api()["ok"]
+
                
+
                Compliant solution
                
+
                +from unittest.mock import patch
+
+def call_api():
+    from app.api import fetch
+    return fetch()
+
+def test_call_api_ok():
+    with patch("app.api.fetch", return_value={"ok": True}):
+        assert call_api()["ok"]
+
                
+
                Noncompliant code example
                
+
                +def test_compute(mocker):
+    mocker.patch("module.target", lambda x, y: 7)  # Noncompliant
+    assert compute(1, 2) == 7
+
                
+
                Compliant solution
                
+
                +def test_compute(mocker):
+    mock_target = mocker.patch("module.target", return_value=7)
+    assert compute(1, 2) == 7
+    mock_target.assert_called_once_with(1, 2)
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9081.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9081.json
new file mode 100644
index 0000000000..7a16c1c003
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9081.json
@@ -0,0 +1,24 @@
+{
+  "title": "Mocks should use return_value instead of patching with a lambda that only returns a value",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9081",
+  "sqKey": "S9081",
+  "scope": "Tests",
+  "quickfix": "covered",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9083.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9083.html
new file mode 100644
index 0000000000..96e090c172
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9083.html
@@ -0,0 +1,70 @@
+
                This rule raises an issue when an argument-free @pytest.fixture or @pytest.mark.* decorator uses parentheses
+inconsistently with the configured style.
                
+
                By default, empty parentheses are not allowed, matching the official pytest documentation. Analysis may be configured to require empty parentheses
+instead.
                
+
                Why is this an issue?
                
+
                For argument-free @pytest.fixture and @pytest.mark.* decorators, parentheses are optional:
                
+
                +@pytest.fixture
+def sample():
+    return 1
+
+@pytest.fixture()
+def other():
+    return 2
+
                
+
                Both forms are valid, but mixing them makes tests harder to scan and review. Prefer one style consistently. The default style omits empty
+parentheses, which matches pytest’s own documentation.
                
+
                Decorators that take arguments still need parentheses:
                
+
                +@pytest.fixture(scope='module')
+def db():
+    ...
+
+@pytest.mark.parametrize('value', [1, 2])
+def test_values(value):
+    ...
+
                
+
                What is the potential impact?
                
+
                Inconsistent parentheses on fixtures and marks add noise during reviews without changing behavior. Aligning on one style keeps test suites easier
+to read and maintain.
                
+
                How to fix it
                
+
                Omit empty parentheses on argument-free @pytest.fixture and @pytest.mark.* decorators (the default style). If analysis is
+configured to require parentheses, add empty () instead.
                
+
                Do not change decorators that already pass arguments.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.fixture()  # Noncompliant
+def sample():
+    return 1
+
+@pytest.mark.slow()  # Noncompliant
+def test_sample(sample):
+    assert sample == 1
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.fixture
+def sample():
+    return 1
+
+@pytest.mark.slow
+def test_sample(sample):
+    assert sample == 1
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9083.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9083.json
new file mode 100644
index 0000000000..ce21aa9833
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9083.json
@@ -0,0 +1,24 @@
+{
+  "title": "Pytest fixture and mark decorators should use consistent parentheses style",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "1min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-9083",
+  "sqKey": "S9083",
+  "scope": "Tests",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9084.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9084.html
new file mode 100644
index 0000000000..b394d99fe8
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9084.html
@@ -0,0 +1,88 @@
+
                This rule raises an issue when pytest is imported with from pytest import …​ or under an alias such as import
+pytest as …​, instead of a plain import pytest.
                
+
                In Python, this refers to imports such as:
                
+
                  
+  
                • from pytest import mark, raises (and other from pytest import …​ forms, including subpackages)
                  • 
+  
                • import pytest as pt (and other aliases that rename pytest)
                  • 
+
                
+
                Why is this an issue?
                
+
                Pytest is conventionally imported as a module: import pytest. Members are then accessed as pytest.raises,
+pytest.mark, pytest.fixture, and so on.
                
+
                from pytest import …​
                
+
                Importing selected names from pytest scatters short unbound names through the test file:
                
+
                +from pytest import mark, raises
+
+@mark.skip
+def test_invalid_input():
+    with raises(ValueError):
+        process_data('hello')
+
                
+
                Readers must check the import list to know that mark and raises come from pytest. Mixing import pytest in
+some files with from pytest import …​ in others makes the suite harder to skim and to search.
                
+
                Aliased imports
                
+
                Renaming the module hides the standard name:
                
+
                +import pytest as pt
+
+def test_invalid_input():
+    with pt.raises(ValueError):
+        process_data('hello')
+
                
+
                import pytest keeps every call site consistent across the project.
                
+
                Preferred form
                
+
                +import pytest
+
+@pytest.mark.skip
+def test_invalid_input():
+    with pytest.raises(ValueError):
+        process_data('hello')
+
                
+
                What is the potential impact?
                
+
                Inconsistent pytest imports force maintainers to resolve where helpers come from and slow down reviews. A single import pytest style
+keeps test APIs recognizable and easier to search across the suite.
                
+
                How to fix it
                
+
                Replace from pytest import …​ and aliased imports with import pytest, then qualify members as pytest…​..
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from pytest import mark, raises  # Noncompliant
+
+@mark.skip
+def test_invalid_input():
+    with raises(ValueError):
+        process_data('hello')
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.mark.skip
+def test_invalid_input():
+    with pytest.raises(ValueError):
+        process_data('hello')
+
                
+
                Noncompliant code example
                
+
                +import pytest as pt  # Noncompliant
+
+def test_invalid_input():
+    with pt.raises(ValueError):
+        process_data('hello')
+
                
+
                Compliant solution
                
+
                +import pytest
+
+def test_invalid_input():
+    with pytest.raises(ValueError):
+        process_data('hello')
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9084.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9084.json
new file mode 100644
index 0000000000..85c8735cb7
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9084.json
@@ -0,0 +1,24 @@
+{
+  "title": "pytest should be imported as a module",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-9084",
+  "sqKey": "S9084",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9088.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9088.html
new file mode 100644
index 0000000000..9c97d73266
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9088.html
@@ -0,0 +1,92 @@
+
                When testing code that should emit a warning, having multiple method calls in the tested code makes it unclear which call is expected to emit the
+warning.
                
+
                In Python with pytest, this refers to with pytest.warns(…​): bodies that contain more than one statement, or a single statement with
+multiple method invocations that could emit the expected warning.
                
+
                Why is this an issue?
                
+
                When writing tests for warnings, clarity is essential. If you put several method calls inside a pytest.warns block, or chain multiple
+invocations in the tested expression, it becomes ambiguous which specific call is expected to emit the warning.
                
+
                For example, consider this code:
                
+
                +with pytest.warns(UserWarning):
+    get_item().process()
+
                
+
                Here, both get_item() and process() could potentially emit a UserWarning. The test does not make it explicit
+which method is expected to warn. The same ambiguity appears when setup and the code under test share the with block:
                
+
                +with pytest.warns(UserWarning):
+    setup()
+    do_work()
+
                
+
                By isolating the method call you want to test, you make the test explicit and unambiguous. This improves readability and maintainability, and makes
+your test suite a better specification of expected behavior.
                
+
                What is the potential impact?
                
+
                Writing tests with multiple method calls when testing for warnings reduces test quality:
                
+
                  
+  
                • Incorrect test coverage: You may think you are testing one method’s warning behavior when you are actually testing
+  another’s.
                  • 
+  
                • Maintenance burden: Other developers (or future you) will struggle to understand what the test is verifying.
                  • 
+  
                • Reduced confidence: Passing tests do not guarantee that the specific behavior you intended to test is working correctly.
                  • 
+
                
+
                How to fix it
                
+
                When using pytest’s pytest.warns() context manager, extract intermediate method calls into separate variables before the assertion,
+and move setup outside the with block. This ensures only the final method call that you want to test is inside the warning-testing
+block.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+def test_process():
+    # Which method emits the warning: get_item() or process()?
+    with pytest.warns(UserWarning):  # Noncompliant
+        get_item().process()
+
                
+
                Compliant solution
                
+
                +import pytest
+
+def test_process():
+    item = get_item()
+    with pytest.warns(UserWarning):
+        item.process()
+
                
+
                Noncompliant code example
                
+
                +import warnings
+import pytest
+
+def setup():
+    pass
+
+def test_multiple_statements():
+    with pytest.warns(UserWarning):  # Noncompliant
+        setup()
+        warnings.warn("x", UserWarning)
+
                
+
                Compliant solution
                
+
                +import warnings
+import pytest
+
+def setup():
+    pass
+
+def test_multiple_statements():
+    setup()
+    with pytest.warns(UserWarning):
+        warnings.warn("x", UserWarning)
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S5778} - Only one method invocation is expected when testing runtime exceptions
                  • 
+  
                • {rule:python:S5914} - Assertions should not fail or succeed unconditionally
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9088.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9088.json
new file mode 100644
index 0000000000..a5f9d6a423
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9088.json
@@ -0,0 +1,24 @@
+{
+  "title": "Only one method invocation is expected when testing warnings",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9088",
+  "sqKey": "S9088",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9100.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9100.html
new file mode 100644
index 0000000000..c508464729
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9100.html
@@ -0,0 +1,51 @@
+
                This rule raises an issue when a @pytest.fixture yields a value with no teardown code after the yield.
                
+
                Why is this an issue?
                
+
                A fixture should use yield only when there is teardown after the test. Yielding with nothing afterward is equivalent to
+return, but reads as if cleanup were intended:
                
+
                +@pytest.fixture
+def useless_yield():
+    data = load()
+    yield data
+
                
+
                Use return when no teardown is needed:
                
+
                +@pytest.fixture
+def useless_yield():
+    return load()
+
                
+
                What is the potential impact?
                
+
                A useless yield suggests teardown that does not exist, which misleads readers about fixture lifecycle and resource ownership.
                
+
                How to fix it
                
+
                When a fixture has no teardown, replace yield with return.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.fixture
+def useless_yield():
+    data = load()
+    yield data  # Noncompliant
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.fixture
+def useless_yield():
+    return load()
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S8994} - Fixtures should not contain more than one yield
                  • 
+  
                • {rule:python:S9080} - Pytest fixtures should use yield for teardown
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9100.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9100.json
new file mode 100644
index 0000000000..d44836258f
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9100.json
@@ -0,0 +1,24 @@
+{
+  "title": "Pytest fixtures without teardown should use return instead of yield",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9100",
+  "sqKey": "S9100",
+  "scope": "Tests",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  },
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9106.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9106.html
new file mode 100644
index 0000000000..06d394619b
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9106.html
@@ -0,0 +1,54 @@
+
                This rule raises an issue when a pytest test or fixture parameter declares a default value.
                
+
                Why is this an issue?
                
+
                A default on a pytest test or fixture parameter is always used. Pytest does not inject a fixture of the same name when a default is present:
                
+
                +@pytest.fixture
+def value():
+    return 42
+
+def test_positive(value=1):  # Always gets 1; fixture is ignored
+    assert value > 0
+
                
+
                That hides missing fixtures and makes the test run with a hard-coded value instead of the intended fixture. Remove the default so pytest can inject
+the parameter, or stop treating the name as a fixture dependency.
                
+
                What is the potential impact?
                
+
                Defaults on test or fixture parameters silently block fixture injection, so tests can pass with hard-coded values while the real fixture is never
+applied.
                
+
                How to fix it
                
+
                Remove default values from pytest test and fixture parameters so fixtures can be injected by name.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.fixture
+def value():
+    return 42
+
+def test_with_default(value=1):  # Noncompliant
+    assert value > 0
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.fixture
+def value():
+    return 42
+
+def test_with_default(value):
+    assert value > 0
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S9079} - Unused fixtures should be activated with pytest.mark.usefixtures
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9106.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9106.json
new file mode 100644
index 0000000000..0098275318
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9106.json
@@ -0,0 +1,24 @@
+{
+  "title": "Pytest test and fixture parameters should not declare default values",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9106",
+  "sqKey": "S9106",
+  "scope": "Tests",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  },
+  "quickfix": "unknown"
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9116.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9116.html
new file mode 100644
index 0000000000..5b33b4727f
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9116.html
@@ -0,0 +1,53 @@
+
                This rule raises an issue when @pytest.fixture options are passed as positional arguments.
                
+
                In Python, this refers to @pytest.fixture(…​) with options passed as positional arguments, such as
+@pytest.fixture("module").
                
+
                Why is this an issue?
                
+
                Passing options like scope as positional arguments to @pytest.fixture is ambiguous and has been removed in pytest 6.0 and later. Use
+keyword arguments:
                
+
                +@pytest.fixture("module")  # Removed; use keyword arguments
+def shared_state():
+    return {}
+
                
+
                Prefer:
                
+
                +@pytest.fixture(scope="module")
+def shared_state():
+    return {}
+
                
+
                What is the potential impact?
                
+
                Positional arguments to @pytest.fixture are rejected by modern pytest, so fixtures written this way fail to load or raise errors at
+collection time.
                
+
                How to fix it
                
+
                Pass fixture options with keywords (for example scope="module").
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +import pytest
+
+@pytest.fixture("module")  # Noncompliant
+def scoped():
+    return []
+
                
+
                Compliant solution
                
+
                +import pytest
+
+@pytest.fixture(scope="module")
+def scoped():
+    return []
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S9076} - Deprecated pytest.yield_fixture should be replaced with pytest.fixture
                  • 
+  
                • {rule:python:S9117} - Pytest fixtures should not declare the default scope="function"
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9116.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9116.json
new file mode 100644
index 0000000000..94abd09406
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9116.json
@@ -0,0 +1,24 @@
+{
+  "title": "Pytest fixture options should be passed as keyword arguments",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9116",
+  "sqKey": "S9116",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9117.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9117.html
new file mode 100644
index 0000000000..baeeded857
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9117.html
@@ -0,0 +1,37 @@
+
                This rule raises an issue when @pytest.fixture explicitly sets scope="function", which is already the default.
                
+
                In Python, this refers to @pytest.fixture(scope="function"), which restates the default scope.
                
+
                Why is this an issue?
                
+
                The default fixture scope is "function". Writing scope="function" explicitly does not change behavior and adds clutter.
+Drop the argument and use @pytest.fixture alone unless you need a non-default value such as "class", "module",
+"package", or "session":
                
+
                +import pytest
+
+@pytest.fixture(scope="function")  # Noncompliant
+def default_scope():
+    return {}
+
                
+
                +import pytest
+
+@pytest.fixture
+def default_scope():
+    return {}
+
                
+
                What is the potential impact?
                
+
                Redundant scope="function" distracts readers without changing fixture lifetime, which slows review of real scoping choices.
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S9076} - Deprecated pytest.yield_fixture should be replaced with pytest.fixture
                  • 
+  
                • {rule:python:S9116} - Pytest fixture options should be passed as keyword arguments
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9117.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9117.json
new file mode 100644
index 0000000000..cdd984aa28
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9117.json
@@ -0,0 +1,24 @@
+{
+  "title": "Pytest fixtures should not declare the default scope\u003d\"function\"",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "2min"
+  },
+  "tags": [
+    "pytest",
+    "tests"
+  ],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-9117",
+  "sqKey": "S9117",
+  "scope": "Tests",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9134.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9134.html
new file mode 100644
index 0000000000..c953b3c693
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9134.html
@@ -0,0 +1,68 @@
+
                This rule raises an issue when a data validation method that is expected to transform or validate field values has a code path that does not
+explicitly return a value.
                
+
                In Python, this specifically applies to Pydantic’s field_validator decorator methods.
                
+
                Why is this an issue?
                
+
                In data validation frameworks, validation methods are functions or methods (marked by framework-specific decorators or annotations) that validate
+and optionally transform field values during object construction. These frameworks use the validator’s return value as the final field value.
                
+
                When a validation method does not explicitly return a value, the language runtime implicitly returns a null/None value. The framework then stores
+this null/None as the field value, regardless of the field’s type annotation or declaration. This happens silently - no error is raised, no warning is
+emitted, and the object appears to construct successfully.
                
+
                This creates a silent data corruption bug. A field declared as string, integer, or any other non-nullable type will contain null/None at runtime,
+violating its type contract without any indication to the caller.
                
+
                The issue commonly occurs in two scenarios:
                
+
                  
+  
                • Forgotten return statement: The developer modifies the value in place but forgets to return it.
                  • 
+  
                • Conditional validation: The validator raises an exception for invalid values but forgets to return the value on the valid code
+  path.
                  • 
+
                
+
                Because the bug is silent at construction time, it only surfaces later when code that relies on the correct type encounters the unexpected
+null/None value.
                
+
                What is the potential impact?
                
+
                Data Corruption
                
+
                Fields that should never be null silently become null, breaking the data model’s integrity. Downstream code that trusts the type declaration will
+fail or produce incorrect results.
                
+
                For example, a name field declared as a non-nullable string type might become null, causing string operations to raise type-related
+errors or conditional checks to behave incorrectly.
                
+
                Schema Violations
                
+
                When serializing the model using standard serialization methods, fields will be serialized as None instead of their expected types.
+This breaks API contracts, database constraints, and data interchange formats.
                
+
                External systems receiving this data may reject it or, worse, accept it and propagate the corruption.
                
+
                Difficult Debugging
                
+
                Because no exception is raised during model construction, the bug manifests far from its source. You might see failures in business logic that
+expects valid data types.
                
+
                Tracing these failures back to the missing return statement in a validator can be time-consuming.
                
+
                In Python with Pydantic, this specifically occurs when using model_dump() or model_dump_json() serialization methods.
                
+
                How to fix it
                
+
                Always explicitly return the validated value from a field_validator method. If you modify the value, return the modified version. If
+you only validate without transformation, return the original value.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from pydantic import BaseModel, field_validator
+
+class UserModel(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def clean_name(cls, v):
+        v = v.lower().strip()  # Noncompliant
+
                
+
                Compliant solution
                
+
                +from pydantic import BaseModel, field_validator
+
+class UserModel(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def clean_name(cls, v):
+        return v.lower().strip()
+
                
+
                Resources
                
+
                Documentation
                
+
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9134.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9134.json
new file mode 100644
index 0000000000..0aee500d10
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9134.json
@@ -0,0 +1,26 @@
+{
+  "title": "Pydantic field validators should explicitly return the validated value",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "pydantic",
+    "pitfall",
+    "type-system"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-9134",
+  "sqKey": "S9134",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9136.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9136.html
new file mode 100644
index 0000000000..5e5d225d5e
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9136.html
@@ -0,0 +1,89 @@
+
                This rule raises an issue when a unittest.mock.Mock (or a mock created by patch / pytest-mock) is used with an assertion
+attribute whose name closely resembles a real mock assertion method — for example a typo such as assert_called_wit instead of
+assert_called_with. This rule only applies to method names that closely match a known assertion API.
                
+
                Typical cases include typos on methods such as assert_called, assert_called_with, assert_called_once_with,
+assert_any_call, assert_has_calls, and assert_not_called, on Mock, MagicMock, or
+mocks returned by unittest.mock.patch / pytest-mock.
                
+
                Why is this an issue?
                
+
                unittest.mock.Mock creates child attributes on demand. Any unknown name becomes another Mock, including misspelled
+assertion methods.
                
+
                Calling mock.assert_called_wit(…​) therefore does not fail: it builds a new mock and returns it. The test keeps passing even though
+the intended assertion never ran.
                
+
                Misspelled assertion
                
+
                +mock = Mock()
+service(mock)
+mock.assert_called_wit(1, 2)  # typo: creates a child mock, does not assert
+
                
+
                The call looks like an assertion, but it is only attribute access on a Mock.
                
+
                Correct assertion name
                
+
                +mock = Mock()
+service(mock)
+mock.assert_called_with(1, 2)
+
                
+
                Using a real assertion method fails the test when the mock was not called as expected.
                
+
                This rule reports only when the attribute name is a near miss of a documented Mock assertion method (a small spelling difference), so
+clearly unrelated assert_* names are not flagged. Review manually only if the code intentionally reads a nested mock attribute whose name
+merely resembles an assertion helper (this is rare and usually a smell of its own).
                
+
                What is the potential impact?
                
+
                Broken tests can pass silently. Regressions that the assertion was meant to catch go unnoticed, which weakens confidence in the suite and can let
+faulty behavior reach production.
                
+
                How to fix it
                
+
                Rename the attribute to the correct Mock assertion method so the test performs the check you intended. Do not change production code:
+only the test assertion spelling should change, and the asserted call arguments should stay the same.
                
+
                Optionally harden the mock with autospec (see {rule:python:S9137}) so future unknown attribute names raise instead of creating child mocks. That is
+a separate improvement; the required fix for this issue is correcting the assertion name.
                
+
                A won’t-fix / accepted trade-off is not appropriate for a misspelled assertion: the test is not verifying what it claims. Mark as a false positive
+only if analysis mistook a non-assertion attribute access for a mock assertion API.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from unittest.mock import Mock
+
+def test_process_calls_save():
+    saver = Mock()
+    process(saver, "item")
+    saver.save.assert_called_wit("item")  # Noncompliant
+
                
+
                Compliant solution
                
+
                +from unittest.mock import Mock
+
+def test_process_calls_save():
+    saver = Mock()
+    process(saver, "item")
+    saver.save.assert_called_with("item")
+
                
+
                Noncompliant code example
                
+
                +from unittest.mock import patch
+
+def test_notify():
+    with patch("app.notify.send") as send:
+        notify_user("u1")
+        send.assert_called_once_wit("u1")  # Noncompliant
+
                
+
                Compliant solution
                
+
                +from unittest.mock import patch
+
+def test_notify():
+    with patch("app.notify.send") as send:
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S9137} - Mocks should be created with autospec
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9136.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9136.json
new file mode 100644
index 0000000000..d5904b2b0b
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9136.json
@@ -0,0 +1,25 @@
+{
+  "title": "Mock assertion method names should be spelled correctly",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [
+    "tests",
+    "pitfall"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9136",
+  "sqKey": "S9136",
+  "scope": "Tests",
+  "quickfix": "covered",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "LOGICAL"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9137.html b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9137.html
new file mode 100644
index 0000000000..b66d1bb81f
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9137.html
@@ -0,0 +1,100 @@
+
                This rule raises an issue when a unittest.mock.Mock or MagicMock is created without an autospec (or equivalent
+spec / spec_set), including patch / pytest-mock calls that omit autospec=True.
                
+
                In Python, this includes:
                
+
                  
+  
                • Mock() / MagicMock() without spec / spec_set
                  • 
+  
                • patch("target") / patch.object(...) without autospec=True (or an explicit spec)
                  • 
+  
                • Equivalent mocker.patch(...) calls from pytest-mock
                  • 
+
                
+
                Why is this an issue?
                
+
                By default, unittest.mock.Mock accepts any attribute name and any call signature. That hides mistakes: typos on methods under test,
+wrong argument lists, and misspelled assertion helpers all succeed until something else fails later.
                
+
                Autospeccing means building the mock from a real object or class so that it mirrors that API. Missing attributes raise AttributeError,
+and calls are checked against the real signature. That turns silent mock mistakes into loud test failures.
                
+
                Mock without autospec
                
+
                +from unittest.mock import Mock
+
+client = Mock()
+client.fetsh("id")  # typo is accepted; returns another Mock
+
                
+
                Mock with autospec
                
+
                +from unittest.mock import create_autospec
+
+client = create_autospec(ApiClient)
+client.fetch("id")  # AttributeError if fetch does not exist on ApiClient
+
                
+
                Exceptions
                
+
                This rule does not raise when spec, spec_set, autospec, or create_autospec is already used.
                
+
                A bare Mock can be acceptable when there is no useful real collaborator to copy — for example a throwaway callable stub, or a test
+double invented only for this test with no production type. In those cases, review manually before changing the code; prefer autospec whenever a real
+class or function exists.
                
+
                What is the potential impact?
                
+
                Without autospec, tests can pass while still exercising incorrect interactions with dependencies. API renames and signature changes may go
+unnoticed, and assertion typos on the mock can pass for the same reason.
                
+
                How to fix it
                
+
                Create the mock from the real collaborator so it mirrors that API:
                
+
                  
+  
                • Use create_autospec(SomeClass) or create_autospec(some_function) when you hold the mock in a variable.
                  • 
+  
                • Use patch("module.target", autospec=True) (or mocker.patch(…​, autospec=True)) when replacing an import path for the
+  duration of the test.
                  • 
+  
                • Use spec= / spec_set= on Mock / MagicMock when you need a limited mirror of an instance
+  without full autospec behaviour; prefer autospec / create_autospec when you want signature checking as well.
                  • 
+
                
+
                Enabling autospec may cause existing tests to fail if they called methods that do not exist on the real API or used the wrong signature. That
+failure is intended: update the test (or the call under test) to match the real collaborator. Production behaviour should stay the same; only the test
+double becomes stricter.
                
+
                Use a plain Mock only when there is no useful real API to copy. If the bare mock is intentional for that reason, treat the issue as an
+accepted trade-off after review rather than a false positive of the analysis.
                
+
                Code examples
                
+
                Noncompliant code example
                
+
                +from unittest.mock import Mock
+
+def test_checkout():
+    payments = Mock()  # Noncompliant
+    checkout(payments, order)
+    payments.charge.assert_called_once_with(order.total)
+
                
+
                Compliant solution
                
+
                +from unittest.mock import create_autospec
+
+def test_checkout():
+    payments = create_autospec(PaymentGateway)
+    checkout(payments, order)
+    payments.charge.assert_called_once_with(order.total)
+
                
+
                Noncompliant code example
                
+
                +from unittest.mock import patch
+
+def test_notify():
+    with patch("app.notify.send") as send:  # Noncompliant
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
                
+
                Compliant solution
                
+
                +from unittest.mock import patch
+
+def test_notify():
+    with patch("app.notify.send", autospec=True) as send:
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
                
+
                Resources
                
+
                Documentation
                
+
+
                Related rules
                
+
                  
+  
                • {rule:python:S9136} - Mock assertion method names should be spelled correctly
                  • 
+
                
+
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9137.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9137.json
new file mode 100644
index 0000000000..c99458662f
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S9137.json
@@ -0,0 +1,25 @@
+{
+  "title": "Mocks should be created with autospec",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "10min"
+  },
+  "tags": [
+    "tests",
+    "pitfall"
+  ],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-9137",
+  "sqKey": "S9137",
+  "scope": "Tests",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM",
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "COMPLETE"
+  }
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/Sonar_agentic_AI_profile.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/Sonar_agentic_AI_profile.json
new file mode 100644
index 0000000000..88ce989453
--- /dev/null
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/Sonar_agentic_AI_profile.json
@@ -0,0 +1,311 @@
+{
+  "name": "Sonar agentic AI",
+  "ruleKeys": [
+    "BackticksUsage",
+    "ExecStatementUsage",
+    "InequalityUsage",
+    "PreIncrementDecrement",
+    "PrintStatementUsage",
+    "S100",
+    "S101",
+    "S107",
+    "S108",
+    "S112",
+    "S116",
+    "S117",
+    "S125",
+    "S905",
+    "S930",
+    "S935",
+    "S1045",
+    "S1066",
+    "S1134",
+    "S1135",
+    "S1143",
+    "S1144",
+    "S1172",
+    "S1186",
+    "S1192",
+    "S1226",
+    "S1244",
+    "S1313",
+    "S1481",
+    "S1515",
+    "S1542",
+    "S1607",
+    "S1656",
+    "S1700",
+    "S1716",
+    "S1751",
+    "S1763",
+    "S1764",
+    "S1854",
+    "S1862",
+    "S1871",
+    "S2053",
+    "S2068",
+    "S2077",
+    "S2092",
+    "S2115",
+    "S2159",
+    "S2190",
+    "S2201",
+    "S2208",
+    "S2245",
+    "S2257",
+    "S2275",
+    "S2612",
+    "S2638",
+    "S2710",
+    "S2711",
+    "S2734",
+    "S2737",
+    "S2755",
+    "S2757",
+    "S2761",
+    "S2772",
+    "S2823",
+    "S2836",
+    "S2876",
+    "S3329",
+    "S3330",
+    "S3358",
+    "S3403",
+    "S3457",
+    "S3516",
+    "S3626",
+    "S3699",
+    "S3752",
+    "S3776",
+    "S3827",
+    "S3862",
+    "S3923",
+    "S3981",
+    "S3984",
+    "S3985",
+    "S4143",
+    "S4144",
+    "S4423",
+    "S4426",
+    "S4433",
+    "S4487",
+    "S4502",
+    "S4507",
+    "S4790",
+    "S4830",
+    "S5122",
+    "S5247",
+    "S5332",
+    "S5344",
+    "S5361",
+    "S5443",
+    "S5445",
+    "S5527",
+    "S5542",
+    "S5547",
+    "S5549",
+    "S5603",
+    "S5607",
+    "S5632",
+    "S5642",
+    "S5644",
+    "S5655",
+    "S5659",
+    "S5704",
+    "S5706",
+    "S5707",
+    "S5708",
+    "S5709",
+    "S5712",
+    "S5714",
+    "S5717",
+    "S5719",
+    "S5720",
+    "S5722",
+    "S5724",
+    "S5727",
+    "S5747",
+    "S5754",
+    "S5756",
+    "S5780",
+    "S5781",
+    "S5795",
+    "S5796",
+    "S5797",
+    "S5799",
+    "S5806",
+    "S5807",
+    "S5828",
+    "S5842",
+    "S5843",
+    "S5845",
+    "S5850",
+    "S5852",
+    "S5855",
+    "S5860",
+    "S5864",
+    "S5868",
+    "S5869",
+    "S5886",
+    "S5890",
+    "S5899",
+    "S5905",
+    "S5914",
+    "S5915",
+    "S5918",
+    "S5994",
+    "S5996",
+    "S6001",
+    "S6002",
+    "S6019",
+    "S6035",
+    "S6243",
+    "S6246",
+    "S6249",
+    "S6252",
+    "S6262",
+    "S6265",
+    "S6270",
+    "S6275",
+    "S6281",
+    "S6302",
+    "S6303",
+    "S6304",
+    "S6308",
+    "S6317",
+    "S6319",
+    "S6321",
+    "S6323",
+    "S6326",
+    "S6327",
+    "S6328",
+    "S6329",
+    "S6330",
+    "S6331",
+    "S6332",
+    "S6333",
+    "S6353",
+    "S6377",
+    "S6395",
+    "S6396",
+    "S6397",
+    "S6418",
+    "S6437",
+    "S6463",
+    "S6468",
+    "S6537",
+    "S6552",
+    "S6553",
+    "S6556",
+    "S6559",
+    "S6560",
+    "S6659",
+    "S6660",
+    "S6662",
+    "S6663",
+    "S6709",
+    "S6711",
+    "S6714",
+    "S6725",
+    "S6727",
+    "S6729",
+    "S6730",
+    "S6734",
+    "S6735",
+    "S6741",
+    "S6742",
+    "S6779",
+    "S6781",
+    "S6785",
+    "S6786",
+    "S6792",
+    "S6794",
+    "S6795",
+    "S6796",
+    "S6799",
+    "S6863",
+    "S6882",
+    "S6883",
+    "S6887",
+    "S6890",
+    "S6894",
+    "S6900",
+    "S6903",
+    "S6908",
+    "S6911",
+    "S6918",
+    "S6919",
+    "S6925",
+    "S6928",
+    "S6929",
+    "S6971",
+    "S6972",
+    "S6973",
+    "S6974",
+    "S6978",
+    "S6979",
+    "S6982",
+    "S6984",
+    "S6985",
+    "S7483",
+    "S7484",
+    "S7487",
+    "S7488",
+    "S7489",
+    "S7490",
+    "S7491",
+    "S7492",
+    "S7493",
+    "S7494",
+    "S7496",
+    "S7497",
+    "S7498",
+    "S7499",
+    "S7500",
+    "S7501",
+    "S7502",
+    "S7503",
+    "S7504",
+    "S7505",
+    "S7506",
+    "S7507",
+    "S7508",
+    "S7510",
+    "S7511",
+    "S7514",
+    "S7515",
+    "S7516",
+    "S7517",
+    "S7608",
+    "S7609",
+    "S7613",
+    "S7614",
+    "S7617",
+    "S7618",
+    "S7619",
+    "S7620",
+    "S7621",
+    "S7622",
+    "S7625",
+    "S7931",
+    "S7942",
+    "S7943",
+    "S8371",
+    "S8375",
+    "S8385",
+    "S8389",
+    "S8392",
+    "S8396",
+    "S8397",
+    "S8400",
+    "S8401",
+    "S8405",
+    "S8409",
+    "S8410",
+    "S8411",
+    "S8413",
+    "S8414",
+    "S8415",
+    "S8786"
+  ]
+}
diff --git a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/Sonar_way_profile.json b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/Sonar_way_profile.json
index ef644bdcf8..29ac9e3439 100644
--- a/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/Sonar_way_profile.json
+++ b/python-checks/src/main/resources/org/sonar/l10n/py/rules/python/Sonar_way_profile.json
@@ -74,6 +74,7 @@
     "S3330",
     "S3358",
     "S3403",
+    "S3415",
     "S3457",
     "S3516",
     "S3626",
@@ -95,9 +96,7 @@
     "S4502",
     "S4507",
     "S4790",
-    "S4828",
     "S4830",
-    "S5042",
     "S5122",
     "S5247",
     "S5332",
@@ -134,6 +133,8 @@
     "S5747",
     "S5754",
     "S5756",
+    "S5778",
+    "S5779",
     "S5780",
     "S5781",
     "S5795",
@@ -151,6 +152,7 @@
     "S5855",
     "S5857",
     "S5860",
+    "S5863",
     "S5864",
     "S5868",
     "S5869",
@@ -162,6 +164,8 @@
     "S5914",
     "S5915",
     "S5918",
+    "S5958",
+    "S5976",
     "S5994",
     "S5996",
     "S6001",
@@ -327,6 +331,73 @@
     "S8412",
     "S8413",
     "S8414",
-    "S8415"
+    "S8415",
+    "S8490",
+    "S8492",
+    "S8493",
+    "S8494",
+    "S8495",
+    "S8500",
+    "S8502",
+    "S8503",
+    "S8504",
+    "S8505",
+    "S8507",
+    "S8508",
+    "S8509",
+    "S8510",
+    "S8511",
+    "S8512",
+    "S8513",
+    "S8514",
+    "S8515",
+    "S8516",
+    "S8517",
+    "S8518",
+    "S8519",
+    "S8520",
+    "S8521",
+    "S8572",
+    "S8685",
+    "S8714",
+    "S8786",
+    "S8900",
+    "S8903",
+    "S8904",
+    "S8905",
+    "S8906",
+    "S8953",
+    "S8963",
+    "S8966",
+    "S8971",
+    "S8973",
+    "S8974",
+    "S8978",
+    "S8992",
+    "S8993",
+    "S8994",
+    "S8997",
+    "S8998",
+    "S8999",
+    "S9000",
+    "S9001",
+    "S9002",
+    "S9073",
+    "S9074",
+    "S9075",
+    "S9076",
+    "S9077",
+    "S9078",
+    "S9080",
+    "S9081",
+    "S9083",
+    "S9084",
+    "S9088",
+    "S9100",
+    "S9106",
+    "S9116",
+    "S9117",
+    "S9134",
+    "S9136"
   ]
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AfterJumpStatementCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AfterJumpStatementCheckTest.java
index 48e9b48257..e9cae0c15b 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AfterJumpStatementCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AfterJumpStatementCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AllBranchesAreIdenticalCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AllBranchesAreIdenticalCheckTest.java
index 92c32f7f4d..e5d5cccc19 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AllBranchesAreIdenticalCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AllBranchesAreIdenticalCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ArgumentNumberCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ArgumentNumberCheckTest.java
index ebc11d1bf9..bb2b01ff62 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ArgumentNumberCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ArgumentNumberCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ArgumentTypeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ArgumentTypeCheckTest.java
index f899693f8c..f92dca3c26 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ArgumentTypeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ArgumentTypeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AsyncAwsLambdaHandlerCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AsyncAwsLambdaHandlerCheckTest.java
index bc4cba40f3..24b7e97d77 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AsyncAwsLambdaHandlerCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AsyncAwsLambdaHandlerCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AsyncFunctionNotAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AsyncFunctionNotAsyncCheckTest.java
index ef04c7b6f7..e773e21e0f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AsyncFunctionNotAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AsyncFunctionNotAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AsyncFunctionWithTimeoutCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AsyncFunctionWithTimeoutCheckTest.java
index 4772dc051f..47c4235d91 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AsyncFunctionWithTimeoutCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AsyncFunctionWithTimeoutCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AsyncLongSleepCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AsyncLongSleepCheckTest.java
index 9641c0e3a5..8bd8e8cabb 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AsyncLongSleepCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AsyncLongSleepCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AsyncWithContextManagerCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AsyncWithContextManagerCheckTest.java
index 3d96bfa539..821da7d725 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AsyncWithContextManagerCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AsyncWithContextManagerCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AsyncioTaskNotStoredCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AsyncioTaskNotStoredCheckTest.java
index 63b1e3bf11..54e61158c7 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AsyncioTaskNotStoredCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AsyncioTaskNotStoredCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsClientExceptionNotCaughtCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsClientExceptionNotCaughtCheckTest.java
index f7c81e5196..309ae7ce0a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsClientExceptionNotCaughtCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsClientExceptionNotCaughtCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsCustomMetricNamespaceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsCustomMetricNamespaceCheckTest.java
index c2fcdb4963..ae57a082e2 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsCustomMetricNamespaceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsCustomMetricNamespaceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsExpectedBucketOwnerCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsExpectedBucketOwnerCheckTest.java
index d010f270b0..831618d64d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsExpectedBucketOwnerCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsExpectedBucketOwnerCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsHardcodedRegionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsHardcodedRegionCheckTest.java
index b901376892..bf7c11cdb4 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsHardcodedRegionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsHardcodedRegionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaClientInstantiationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaClientInstantiationCheckTest.java
index 54eecdf3fa..a98f39bace 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaClientInstantiationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaClientInstantiationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaCrossCallCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaCrossCallCheckTest.java
index 0528d08dcc..047e040c9a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaCrossCallCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaCrossCallCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaReservedEnvironmentVariableCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaReservedEnvironmentVariableCheckTest.java
index 6a09770f72..ae7a1b9f49 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaReservedEnvironmentVariableCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaReservedEnvironmentVariableCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaReturnValueAreSerializableCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaReturnValueAreSerializableCheckTest.java
index 92c7007de3..23a2b49ad0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaReturnValueAreSerializableCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaReturnValueAreSerializableCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaTmpCleanupCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaTmpCleanupCheckTest.java
index 73d34770bc..a69fa562c0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaTmpCleanupCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsLambdaTmpCleanupCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsLongTermAccessKeysCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsLongTermAccessKeysCheckTest.java
index a95b7c9a0f..a6043f3a57 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsLongTermAccessKeysCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsLongTermAccessKeysCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsMissingPaginationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsMissingPaginationCheckTest.java
index b4bfb682ab..de7aecbf78 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsMissingPaginationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsMissingPaginationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/AwsWaitersInsteadOfCustomPollingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/AwsWaitersInsteadOfCustomPollingCheckTest.java
index 02e6ec8042..4940f3e087 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/AwsWaitersInsteadOfCustomPollingCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/AwsWaitersInsteadOfCustomPollingCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BackslashInStringCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BackslashInStringCheckTest.java
index e66392a137..7a9e8bd654 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BackslashInStringCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BackslashInStringCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BackticksUsageCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BackticksUsageCheckTest.java
index b379c6c606..d4a5bee724 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BackticksUsageCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BackticksUsageCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BareRaiseInFinallyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BareRaiseInFinallyCheckTest.java
index 5947316cce..ba91295508 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BareRaiseInFinallyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BareRaiseInFinallyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/StandardInputCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupClassListCheckTest.java
similarity index 59%
rename from python-checks/src/test/java/org/sonar/python/checks/hotspots/StandardInputCheckTest.java
rename to python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupClassListCheckTest.java
index 0c70be5c28..b71ba567a6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/StandardInputCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupClassListCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,14 +14,17 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-package org.sonar.python.checks.hotspots;
+package org.sonar.python.checks;
 
 import org.junit.jupiter.api.Test;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
-class StandardInputCheckTest {
+class BeautifulSoupClassListCheckTest {
+
   @Test
   void test() {
-    PythonCheckVerifier.verify("src/test/resources/checks/hotspots/standardInput.py", new StandardInputCheck());
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/beautifulSoupClassList.py",
+      new BeautifulSoupClassListCheck());
   }
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupDeprecatedNamesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupDeprecatedNamesCheckTest.java
new file mode 100644
index 0000000000..4a5358cf7e
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupDeprecatedNamesCheckTest.java
@@ -0,0 +1,113 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class BeautifulSoupDeprecatedNamesCheckTest {
+
+  private static final BeautifulSoupDeprecatedNamesCheck check = new BeautifulSoupDeprecatedNamesCheck();
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/beautifulSoupDeprecatedNames.py", check);
+  }
+
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("quickFixTestCases")
+  void quickFixMethod(String testName, String before, String after, String expectedMessage) {
+    PythonQuickFixVerifier.verify(check, before, after);
+    PythonQuickFixVerifier.verifyQuickFixMessages(check, before, expectedMessage);
+  }
+
+
+  @Test
+  void quickFixTextKeyword() {
+    String before = """
+      from bs4 import BeautifulSoup
+      soup = BeautifulSoup("", 'html.parser')
+      soup.find_all('a', text='Click here')""";
+    String after = """
+      from bs4 import BeautifulSoup
+      soup = BeautifulSoup("", 'html.parser')
+      soup.find_all('a', string='Click here')""";
+    PythonQuickFixVerifier.verify(check, before, after);
+    PythonQuickFixVerifier.verifyQuickFixMessages(check, before, "Replace 'text' with 'string'");
+  }
+
+  static Stream quickFixTestCases() {
+    return Stream.of(
+      methodCase("findAll", "find_all"),
+      methodCase("findChild", "find"),
+      methodCase("findChildren", "find_all"),
+      methodCase("findNext", "find_next"),
+      methodCase("findAllNext", "find_all_next"),
+      methodCase("findPrevious", "find_previous"),
+      methodCase("findAllPrevious", "find_all_previous"),
+      methodCase("findNextSibling", "find_next_sibling"),
+      methodCase("findNextSiblings", "find_next_siblings"),
+      methodCase("findPreviousSibling", "find_previous_sibling"),
+      methodCase("findPreviousSiblings", "find_previous_siblings"),
+      methodCase("findParent", "find_parent"),
+      methodCase("findParents", "find_parents"),
+      methodCase("replaceWith", "replace_with"),
+      methodCase("getText", "get_text"),
+      attrCase("nextSibling", "next_sibling"),
+      attrCase("previousSibling", "previous_sibling")
+    );
+  }
+
+  private static Arguments methodCase(String deprecated, String modern) {
+    String before = """
+      from bs4 import BeautifulSoup
+      soup = BeautifulSoup("", 'html.parser')
+      soup.%s('a')""".formatted(deprecated);
+    String after = """
+      from bs4 import BeautifulSoup
+      soup = BeautifulSoup("", 'html.parser')
+      soup.%s('a')""".formatted(modern);
+    return Arguments.of(
+      deprecated + " -> " + modern,
+      before,
+      after,
+      "Replace '%s()' with '%s()'".formatted(deprecated, modern)
+    );
+  }
+
+  private static Arguments attrCase(String deprecated, String modern) {
+    String before = """
+      from bs4 import BeautifulSoup
+      soup = BeautifulSoup("", 'html.parser')
+      _ = soup.%s""".formatted(deprecated);
+    String after = """
+      from bs4 import BeautifulSoup
+      soup = BeautifulSoup("", 'html.parser')
+      _ = soup.%s""".formatted(modern);
+    return Arguments.of(
+      deprecated + " -> " + modern,
+      before,
+      after,
+      "Replace '%s' with '%s'".formatted(deprecated, modern)
+    );
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupNoneCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupNoneCheckTest.java
new file mode 100644
index 0000000000..c648bd2576
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupNoneCheckTest.java
@@ -0,0 +1,31 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class BeautifulSoupNoneCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/beautifulSoupNoneCheck.py",
+      new BeautifulSoupNoneCheck()
+    );
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/RegexCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupParserCheckTest.java
similarity index 61%
rename from python-checks/src/test/java/org/sonar/python/checks/hotspots/RegexCheckTest.java
rename to python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupParserCheckTest.java
index 6673ac53d0..740578ecb0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/RegexCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupParserCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,16 +14,16 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-package org.sonar.python.checks.hotspots;
+package org.sonar.python.checks;
 
 import org.junit.jupiter.api.Test;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
-class RegexCheckTest {
+class BeautifulSoupParserCheckTest {
 
   @Test
   void test() {
-    PythonCheckVerifier.verify("src/test/resources/checks/hotspots/regex.py", new RegexCheck());
+    PythonCheckVerifier.verify("src/test/resources/checks/beautifulSoupParser.py", new BeautifulSoupParserCheck());
   }
 
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupRawHtmlInsertionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupRawHtmlInsertionCheckTest.java
new file mode 100644
index 0000000000..2d21ac4a3c
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/BeautifulSoupRawHtmlInsertionCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class BeautifulSoupRawHtmlInsertionCheckTest {
+  @Test
+  void test() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/beautifulSoupRawHtmlInsertion.py",
+      new BeautifulSoupRawHtmlInsertionCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BindToAllNetworkInterfacesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BindToAllNetworkInterfacesCheckTest.java
index 791a3df702..a84bf62ba1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BindToAllNetworkInterfacesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BindToAllNetworkInterfacesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BooleanCheckNotInvertedCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BooleanCheckNotInvertedCheckTest.java
index 0cc2a994f5..d05305b59f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BooleanCheckNotInvertedCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BooleanCheckNotInvertedCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BooleanExpressionInExceptCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BooleanExpressionInExceptCheckTest.java
index 453cf868dc..7f356d62b8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BooleanExpressionInExceptCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BooleanExpressionInExceptCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -74,6 +74,54 @@ void nestedQuickFixTest() {
     verifyQuickFix(before, after);
   }
 
+  @Test
+  void bitwiseOrQuickFixTest() {
+    var before = """
+      try:
+          foo()
+      except ValueError | TypeError | SomeError:
+          pass""";
+
+    var after = """
+      try:
+          foo()
+      except (ValueError, TypeError, SomeError):
+          pass""";
+    verifyQuickFix(before, after);
+  }
+
+  @Test
+  void bitwiseAndQuickFixTest() {
+    var before = """
+      try:
+          foo()
+      except ValueError & TypeError & SomeError:
+          pass""";
+
+    var after = """
+      try:
+          foo()
+      except (ValueError, TypeError, SomeError):
+          pass""";
+    verifyQuickFix(before, after);
+  }
+
+  @Test
+  void mixedOperatorsQuickFixTest() {
+    var before = """
+      try:
+          foo()
+      except (ValueError | TypeError) and SomeError:
+          pass""";
+
+    var after = """
+      try:
+          foo()
+      except (ValueError, TypeError, SomeError):
+          pass""";
+    verifyQuickFix(before, after);
+  }
+
   @Test
   void noQuickFixTest() {
     var before = """
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BreakContinueOutsideLoopCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BreakContinueOutsideLoopCheckTest.java
index 279e1379c1..737c3f1918 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BreakContinueOutsideLoopCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BreakContinueOutsideLoopCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BuiltinGenericsOverTypingModuleCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BuiltinGenericsOverTypingModuleCheckTest.java
index b9ada7e11b..697dbe0c9c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BuiltinGenericsOverTypingModuleCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BuiltinGenericsOverTypingModuleCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BuiltinShadowingAssignmentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BuiltinShadowingAssignmentCheckTest.java
index bf1094bcc4..e1f16e4c86 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BuiltinShadowingAssignmentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BuiltinShadowingAssignmentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/BusyWaitingInAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/BusyWaitingInAsyncCheckTest.java
index c16b3ca9f7..1d9fca5ca5 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/BusyWaitingInAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/BusyWaitingInAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CancellationReraisedInAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CancellationReraisedInAsyncCheckTest.java
index e7312767b7..4813c85f1d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CancellationReraisedInAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CancellationReraisedInAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CancellationScopeNoCheckpointCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CancellationScopeNoCheckpointCheckTest.java
index 6b2b43fc65..5a6c0cf3b7 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CancellationScopeNoCheckpointCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CancellationScopeNoCheckpointCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CaughtExceptionsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CaughtExceptionsCheckTest.java
index 5ec30475cc..bfdbadc4c5 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CaughtExceptionsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CaughtExceptionsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ChangeMethodContractCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ChangeMethodContractCheckTest.java
index b3b558c490..d4535fcaf0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ChangeMethodContractCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ChangeMethodContractCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ChildAndParentExceptionCaughtCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ChildAndParentExceptionCaughtCheckTest.java
index 99eb5179c7..d12290e331 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ChildAndParentExceptionCaughtCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ChildAndParentExceptionCaughtCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ChildRouterBeforeParentRegistrationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ChildRouterBeforeParentRegistrationCheckTest.java
index b592d81f48..5c2ce90699 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ChildRouterBeforeParentRegistrationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ChildRouterBeforeParentRegistrationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CipherBlockChainingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CipherBlockChainingCheckTest.java
index 067a829cea..8c25ca2c63 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CipherBlockChainingCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CipherBlockChainingCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ClassComplexityCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ClassComplexityCheckTest.java
index fb8d1cc131..580305077e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ClassComplexityCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ClassComplexityCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DataEncryptionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ClassFieldDefinedMultipleTimesCheckTest.java
similarity index 59%
rename from python-checks/src/test/java/org/sonar/python/checks/hotspots/DataEncryptionCheckTest.java
rename to python-checks/src/test/java/org/sonar/python/checks/ClassFieldDefinedMultipleTimesCheckTest.java
index 096b70d524..3dc8a4b0fb 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DataEncryptionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ClassFieldDefinedMultipleTimesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,15 +14,16 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-package org.sonar.python.checks.hotspots;
+package org.sonar.python.checks;
 
 import org.junit.jupiter.api.Test;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
-class DataEncryptionCheckTest {
+class ClassFieldDefinedMultipleTimesCheckTest {
 
   @Test
   void test() {
-    PythonCheckVerifier.verify("src/test/resources/checks/hotspots/data_encryption.py", new DataEncryptionCheck());
+    PythonCheckVerifier.verify("src/test/resources/checks/classFieldDefinedMultipleTimes.py", new ClassFieldDefinedMultipleTimesCheck());
   }
+
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ClassMethodFirstArgumentNameCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ClassMethodFirstArgumentNameCheckTest.java
index 5640e39ce6..baf954ab49 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ClassMethodFirstArgumentNameCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ClassMethodFirstArgumentNameCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ClassNameCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ClassNameCheckTest.java
index 3f23617baf..cc90665fb3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ClassNameCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ClassNameCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CognitiveComplexityFunctionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CognitiveComplexityFunctionCheckTest.java
index 662d645c51..f4f5ba6386 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CognitiveComplexityFunctionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CognitiveComplexityFunctionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -33,4 +33,23 @@ void test() {
   void default_threshold() {
     PythonCheckVerifier.verify("src/test/resources/checks/cognitiveComplexityFunctionDefault.py", check);
   }
+
+  @Test
+  void no_issue_on_django_generated_migration() {
+    check.setThreshold(0);
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/django/migrations/0001_generated_migration.py", check);
+  }
+
+  @Test
+  void no_issue_on_protobuf_generated_code() {
+    check.setThreshold(0);
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/generated/user_pb2.py", check);
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/generated/user_pb2_grpc.py", check);
+  }
+
+  @Test
+  void issue_on_protobuf_suffix_near_match() {
+    check.setThreshold(0);
+    PythonCheckVerifier.verify("src/test/resources/checks/generated/cognitiveComplexity_pb2_test.py", check);
+  }
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CollapsibleIfStatementsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CollapsibleIfStatementsCheckTest.java
index 777e3c3b35..d140aa0e6a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CollapsibleIfStatementsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CollapsibleIfStatementsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CollectionCreationWrappedInConstructorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CollectionCreationWrappedInConstructorCheckTest.java
index 2316caa89f..7261175b3b 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CollectionCreationWrappedInConstructorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CollectionCreationWrappedInConstructorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CollectionLengthComparisonCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CollectionLengthComparisonCheckTest.java
index 0b43908245..3a98804f3e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CollectionLengthComparisonCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CollectionLengthComparisonCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CommentRegularExpressionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CommentRegularExpressionCheckTest.java
index 89d9076d51..ce9fd08319 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CommentRegularExpressionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CommentRegularExpressionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CommentedCodeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CommentedCodeCheckTest.java
index 041b09dafc..dc02be8c2e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CommentedCodeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CommentedCodeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -39,4 +39,20 @@ void test_encoding() {
     PythonCheckVerifier.verify("src/test/resources/checks/commentedCodeEncoding.py", check);
   }
 
+  @Test
+  void no_issue_on_django_generated_migration() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/django/migrations/0001_generated_migration.py", check);
+  }
+
+  @Test
+  void no_issue_on_protobuf_generated_code() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/generated/user_pb2.py", check);
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/generated/user_pb2_grpc.py", check);
+  }
+
+  @Test
+  void issue_on_protobuf_suffix_near_match() {
+    PythonCheckVerifier.verify("src/test/resources/checks/generated/commentedCode_pb2_test.py", check);
+  }
+
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ComparisonToNoneCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ComparisonToNoneCheckTest.java
index b5df401a2e..4f92eb8943 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ComparisonToNoneCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ComparisonToNoneCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CompressionModulesFromNamespaceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CompressionModulesFromNamespaceCheckTest.java
index 1bf9db42d8..3ef9a8a664 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CompressionModulesFromNamespaceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CompressionModulesFromNamespaceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,15 +17,23 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 class CompressionModulesFromNamespaceCheckTest {
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_314));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ConfusingTypeCheckingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ConfusingTypeCheckingCheckTest.java
index 780be48ee7..737eec8781 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ConfusingTypeCheckingCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ConfusingTypeCheckingCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ConfusingWalrusCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ConfusingWalrusCheckTest.java
index dd65ed056d..6e24522f63 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ConfusingWalrusCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ConfusingWalrusCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ConsistentReturnCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ConsistentReturnCheckTest.java
index 1f299d76ac..3dba8af859 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ConsistentReturnCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ConsistentReturnCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ConstantConditionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ConstantConditionCheckTest.java
index 8f158f125f..d96f119ea6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ConstantConditionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ConstantConditionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ConstantValueDictComprehensionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ConstantValueDictComprehensionCheckTest.java
index 2769180824..412765fa69 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ConstantValueDictComprehensionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ConstantValueDictComprehensionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ControlFlowInTaskGroupCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ControlFlowInTaskGroupCheckTest.java
index 6f8658894a..422d08c47d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ControlFlowInTaskGroupCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ControlFlowInTaskGroupCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/CorsMiddlewareOrderingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/CorsMiddlewareOrderingCheckTest.java
index 36c0f1eb1d..e7e3bc9dbb 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/CorsMiddlewareOrderingCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/CorsMiddlewareOrderingCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DataClassFunctionCallDefaultCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DataClassFunctionCallDefaultCheckTest.java
new file mode 100644
index 0000000000..5ed5e0f297
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/DataClassFunctionCallDefaultCheckTest.java
@@ -0,0 +1,28 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class DataClassFunctionCallDefaultCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/dataClassFunctionCallDefault.py", new DataClassFunctionCallDefaultCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/OsExecCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DataClassOnEnumCheckTest.java
similarity index 61%
rename from python-checks/src/test/java/org/sonar/python/checks/hotspots/OsExecCheckTest.java
rename to python-checks/src/test/java/org/sonar/python/checks/DataClassOnEnumCheckTest.java
index 8500bdf6e6..58f61247a4 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/OsExecCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DataClassOnEnumCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,14 +14,15 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-package org.sonar.python.checks.hotspots;
+package org.sonar.python.checks;
 
 import org.junit.jupiter.api.Test;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
-class OsExecCheckTest {
+class DataClassOnEnumCheckTest {
+
   @Test
   void test() {
-    PythonCheckVerifier.verify("src/test/resources/checks/hotspots/osExec.py", new OsExecCheck());
+    PythonCheckVerifier.verify("src/test/resources/checks/dataClassOnEnum.py", new DataClassOnEnumCheck());
   }
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DataclassFieldDefinitionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DataclassFieldDefinitionCheckTest.java
new file mode 100644
index 0000000000..386430568d
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/DataclassFieldDefinitionCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class DataclassFieldDefinitionCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/dataclassFieldDefinition.py", new DataclassFieldDefinitionCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DbNoPasswordCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DbNoPasswordCheckTest.java
index 0f5d123584..2de623778f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DbNoPasswordCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DbNoPasswordCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DeadStoreCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DeadStoreCheckTest.java
index 07e9e9fa10..1587df1a1f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DeadStoreCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DeadStoreCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DefaultFactoryArgumentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DefaultFactoryArgumentCheckTest.java
index f870fe3549..df68c12b25 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DefaultFactoryArgumentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DefaultFactoryArgumentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DeprecatedNumpyTypesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DeprecatedNumpyTypesCheckTest.java
index 5aeb49ef8b..0a89babf8e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DeprecatedNumpyTypesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DeprecatedNumpyTypesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -55,7 +55,6 @@ def foo():
   
   private static Stream numpyTypeProvider(){
     return Stream.of(
-      Arguments.of("np.bool", "(True)", "bool"),
       Arguments.of("np.int", "(42)", "int"),
       Arguments.of("np.float", "(4.2)", "float"),
       Arguments.of("np.complex", "(-2.0, -1.2)", "complex"),
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DictKeysMembershipTestCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DictKeysMembershipTestCheckTest.java
new file mode 100644
index 0000000000..ac3167aa75
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/DictKeysMembershipTestCheckTest.java
@@ -0,0 +1,28 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class DictKeysMembershipTestCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/dictKeysMembershipTest.py", new DictKeysMembershipTestCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DictionaryDuplicateKeyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DictionaryDuplicateKeyCheckTest.java
index edbbbc9d64..5bcfb80297 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DictionaryDuplicateKeyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DictionaryDuplicateKeyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DictionaryStaticKeyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DictionaryStaticKeyCheckTest.java
index 48a0c3d032..71f8330112 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DictionaryStaticKeyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DictionaryStaticKeyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DirectTypeComparisonCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DirectTypeComparisonCheckTest.java
index c71e244987..5f711ef7e7 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DirectTypeComparisonCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DirectTypeComparisonCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DjangoNonDictSerializationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DjangoNonDictSerializationCheckTest.java
index f1aca14715..886f9c8987 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DjangoNonDictSerializationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DjangoNonDictSerializationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DjangoRenderContextCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DjangoRenderContextCheckTest.java
index f99013a323..2b4b3838d7 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DjangoRenderContextCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DjangoRenderContextCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DoublePrefixOperatorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DoublePrefixOperatorCheckTest.java
index efa7f081e3..2e44ae6da8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DoublePrefixOperatorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DoublePrefixOperatorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DuplicateArgumentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DuplicateArgumentCheckTest.java
index de8091f4e6..f390eba8f0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DuplicateArgumentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DuplicateArgumentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DuplicateBaseClassCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DuplicateBaseClassCheckTest.java
new file mode 100644
index 0000000000..9d1a7c418c
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/DuplicateBaseClassCheckTest.java
@@ -0,0 +1,33 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class DuplicateBaseClassCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/duplicateBaseClass.py", new DuplicateBaseClassCheck());
+  }
+
+  @Test
+  void test_no_issue() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/duplicateBaseClassCompliant.py", new DuplicateBaseClassCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DuplicatedMethodFieldNamesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DuplicatedMethodFieldNamesCheckTest.java
index 6f64d5cdcd..e60aa96a29 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DuplicatedMethodFieldNamesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DuplicatedMethodFieldNamesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/DuplicatedMethodImplementationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/DuplicatedMethodImplementationCheckTest.java
index 629dce9b6c..b12f62fb34 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/DuplicatedMethodImplementationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/DuplicatedMethodImplementationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/EinopsSyntaxCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/EinopsSyntaxCheckTest.java
index 006254dd67..5a9b86fbd0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/EinopsSyntaxCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/EinopsSyntaxCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ElseAfterLoopsWithoutBreakCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ElseAfterLoopsWithoutBreakCheckTest.java
index 887573ef97..ea0ee88741 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ElseAfterLoopsWithoutBreakCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ElseAfterLoopsWithoutBreakCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/EmptyCollectionConstructorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/EmptyCollectionConstructorCheckTest.java
index 1ad49aad9a..24fac657bd 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/EmptyCollectionConstructorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/EmptyCollectionConstructorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/EmptyCollectionMembershipTestCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/EmptyCollectionMembershipTestCheckTest.java
new file mode 100644
index 0000000000..7746976e8a
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/EmptyCollectionMembershipTestCheckTest.java
@@ -0,0 +1,28 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class EmptyCollectionMembershipTestCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/emptyCollectionMembershipTest.py", new EmptyCollectionMembershipTestCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/EmptyFunctionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/EmptyFunctionCheckTest.java
index 5828818578..164204d54c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/EmptyFunctionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/EmptyFunctionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/EmptyNestedBlockCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/EmptyNestedBlockCheckTest.java
index 87cd539ba2..6331b13dfc 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/EmptyNestedBlockCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/EmptyNestedBlockCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/EnumerateUnpackingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/EnumerateUnpackingCheckTest.java
new file mode 100644
index 0000000000..b99f62e831
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/EnumerateUnpackingCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class EnumerateUnpackingCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/enumerateUnpacking.py", new EnumerateUnpackingCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ExceptRethrowingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ExceptRethrowingCheckTest.java
index 08e1c177f3..e8ce69a36d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ExceptRethrowingCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ExceptRethrowingCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ExceptionCauseTypeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ExceptionCauseTypeCheckTest.java
index c784cfa5b8..5429bd7f21 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ExceptionCauseTypeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ExceptionCauseTypeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ExceptionGroupCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ExceptionGroupCheckTest.java
index a848908e6f..c7cd12a8c8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ExceptionGroupCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ExceptionGroupCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ExceptionNotThrownCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ExceptionNotThrownCheckTest.java
index b5a2080c87..f407b4814f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ExceptionNotThrownCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ExceptionNotThrownCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ExceptionSuperClassDeclarationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ExceptionSuperClassDeclarationCheckTest.java
index 4b11469af7..3b2fda1aa8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ExceptionSuperClassDeclarationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ExceptionSuperClassDeclarationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ExecStatementUsageCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ExecStatementUsageCheckTest.java
index 61f0fa2684..c653104835 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ExecStatementUsageCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ExecStatementUsageCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ExitHasBadArgumentsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ExitHasBadArgumentsCheckTest.java
index 02f73db45e..f17e730ae1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ExitHasBadArgumentsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ExitHasBadArgumentsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FStringNestingLevelCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FStringNestingLevelCheckTest.java
index 332fffed7c..dc50192d54 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FStringNestingLevelCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FStringNestingLevelCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,13 +20,21 @@
 
 import java.util.EnumSet;
 
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 class FStringNestingLevelCheckTest {
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test_1() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_312));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FastAPIDependencyAnnotatedCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FastAPIDependencyAnnotatedCheckTest.java
index 45358b3aac..e80e707d76 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FastAPIDependencyAnnotatedCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FastAPIDependencyAnnotatedCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,10 +21,38 @@
 
 class FastAPIDependencyAnnotatedCheckTest {
 
-  private static final FastAPIDependencyAnnotatedCheck check = new FastAPIDependencyAnnotatedCheck();
+  @Test
+  void raw_candidates() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/fastAPIDependencyAnnotated.py",
+      new FastAPIDependencyAnnotatedCheck(FastAPIDependencyAnnotatedCheck.IssueReportingMode.DISABLE_FILE_LOCAL_SUPPRESSION));
+  }
+
+  @Test
+  void suppresses_issues_in_old_style_dominant_files() {
+    PythonCheckVerifier.verifyNoIssue(
+      "src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicOldStyleDominant.py",
+      new FastAPIDependencyAnnotatedCheck());
+  }
+
+  @Test
+  void reports_issues_in_annotated_dominant_files() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicAnnotatedDominant.py",
+      new FastAPIDependencyAnnotatedCheck());
+  }
+
+  @Test
+  void reports_issues_when_old_style_sample_is_too_small_for_suppression() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicTooSmallSample.py",
+      new FastAPIDependencyAnnotatedCheck());
+  }
 
   @Test
-  void test() {
-    PythonCheckVerifier.verify("src/test/resources/checks/fastAPIDependencyAnnotated.py", check);
+  void reports_issues_when_mixed_sample_is_too_small_for_suppression() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicMixedTooSmallSample.py",
+      new FastAPIDependencyAnnotatedCheck());
   }
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FastAPIFileUploadFormCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FastAPIFileUploadFormCheckTest.java
index a5ff9134f0..90cccd927d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FastAPIFileUploadFormCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FastAPIFileUploadFormCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FastAPIGenericRouteDecoratorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FastAPIGenericRouteDecoratorCheckTest.java
index f697e9a198..c81507d41b 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FastAPIGenericRouteDecoratorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FastAPIGenericRouteDecoratorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FastAPIHTTPExceptionDocumentedCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FastAPIHTTPExceptionDocumentedCheckTest.java
index f103bb1318..0bb88daaee 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FastAPIHTTPExceptionDocumentedCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FastAPIHTTPExceptionDocumentedCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FastAPIPathParametersCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FastAPIPathParametersCheckTest.java
index 5a68520c1c..f40cc161b1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FastAPIPathParametersCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FastAPIPathParametersCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FastAPIRedundantResponseModelCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FastAPIRedundantResponseModelCheckTest.java
index c45dffbd99..67dc3e248f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FastAPIRedundantResponseModelCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FastAPIRedundantResponseModelCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FastApiImportStringCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FastApiImportStringCheckTest.java
index 686a81b7eb..57e33e0b48 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FastApiImportStringCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FastApiImportStringCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FieldDuplicatesClassNameCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FieldDuplicatesClassNameCheckTest.java
index 4dbeed547c..62e8dcc1cf 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FieldDuplicatesClassNameCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FieldDuplicatesClassNameCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FieldNameCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FieldNameCheckTest.java
index 6d556a3c52..3a8b524e8b 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FieldNameCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FieldNameCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FileComplexityCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FileComplexityCheckTest.java
index dd5daac577..c0bf8d0dfe 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FileComplexityCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FileComplexityCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FileHeaderCopyrightCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FileHeaderCopyrightCheckTest.java
index 363e311849..0e29575af0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FileHeaderCopyrightCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FileHeaderCopyrightCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,7 +21,6 @@
 import java.util.Collections;
 import java.util.List;
 import org.assertj.core.api.Assertions;
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.PythonCheck;
 import org.sonar.plugins.python.api.PythonSubscriptionCheck;
@@ -31,6 +30,7 @@
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class FileHeaderCopyrightCheckTest {
 
@@ -147,7 +147,7 @@ void test_searchPattern_exception() {
 
     Assertions.assertThatThrownBy(() -> SubscriptionVisitor.analyze(check, context)).isInstanceOf(IllegalArgumentException.class);
 
-    IllegalArgumentException e = Assert.assertThrows(IllegalArgumentException.class, () -> SubscriptionVisitor.analyze(check, context));
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> SubscriptionVisitor.analyze(check, context));
     Assertions.assertThat(e.getMessage()).isEqualTo("[FileHeaderCopyrightCheck] Unable to compile the regular expression: "+fileHeaderCopyrightCheck.headerFormat);
   }
 
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FilePermissionsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FilePermissionsCheckTest.java
index cba0ffcb33..92069aed01 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FilePermissionsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FilePermissionsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FixmeCommentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FixmeCommentCheckTest.java
index 8ab95dd280..9ddfbeba89 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FixmeCommentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FixmeCommentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FlaskErrorHandlerStatusCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FlaskErrorHandlerStatusCheckTest.java
index 378b840fc4..74458ae6fe 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FlaskErrorHandlerStatusCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FlaskErrorHandlerStatusCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FlaskHardCodedJWTSecretKeyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FlaskHardCodedJWTSecretKeyCheckTest.java
index 2afaa9f7de..f672c88e72 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FlaskHardCodedJWTSecretKeyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FlaskHardCodedJWTSecretKeyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FlaskHardCodedSecretKeyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FlaskHardCodedSecretKeyCheckTest.java
index 123bbb5031..71719cd3dd 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FlaskHardCodedSecretKeyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FlaskHardCodedSecretKeyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FlaskHeadersDictAccessCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FlaskHeadersDictAccessCheckTest.java
index 113f802011..ba4c2af291 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FlaskHeadersDictAccessCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FlaskHeadersDictAccessCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FlaskPostWithQueryParameterCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FlaskPostWithQueryParameterCheckTest.java
index 99385675c3..92d0231144 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FlaskPostWithQueryParameterCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FlaskPostWithQueryParameterCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FlaskPreprocessRequestCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FlaskPreprocessRequestCheckTest.java
index 07eb5d941c..4b3e0e4dcc 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FlaskPreprocessRequestCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FlaskPreprocessRequestCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FlaskRouteMethodsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FlaskRouteMethodsCheckTest.java
index ddd344deec..dd83cd5acf 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FlaskRouteMethodsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FlaskRouteMethodsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FlaskSendFileMimeTypeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FlaskSendFileMimeTypeCheckTest.java
index f5ab697833..c2c548522d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FlaskSendFileMimeTypeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FlaskSendFileMimeTypeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FlaskViewDecoratorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FlaskViewDecoratorCheckTest.java
index eac3d07b81..e21f96c02a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FlaskViewDecoratorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FlaskViewDecoratorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FloatingPointEqualityCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FloatingPointEqualityCheckTest.java
index ec7f828a5e..2b8121992f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FloatingPointEqualityCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FloatingPointEqualityCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FunctionComplexityCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FunctionComplexityCheckTest.java
index 20591fd7ff..c6b3335212 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FunctionComplexityCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FunctionComplexityCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FunctionNameCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FunctionNameCheckTest.java
index f124dc041b..9aa2a055c6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FunctionNameCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FunctionNameCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FunctionReturnTypeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FunctionReturnTypeCheckTest.java
index 9b5cebb23c..8c68763c8c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FunctionReturnTypeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FunctionReturnTypeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/FunctionUsingLoopVariableCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/FunctionUsingLoopVariableCheckTest.java
index 76434c0d87..8fbb5cde8f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/FunctionUsingLoopVariableCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/FunctionUsingLoopVariableCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/GenericClassTypeParameterCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/GenericClassTypeParameterCheckTest.java
index c70ff835a7..da1f87c870 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/GenericClassTypeParameterCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/GenericClassTypeParameterCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,14 +17,23 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 class GenericClassTypeParameterCheckTest {
+
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test_python_3_12_only() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_312));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/GenericExceptionRaisedCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/GenericExceptionRaisedCheckTest.java
index 84a7cb8a6e..780ed07386 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/GenericExceptionRaisedCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/GenericExceptionRaisedCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/GenericFunctionTypeParameterCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/GenericFunctionTypeParameterCheckTest.java
index feb43ffd13..197d4ae47c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/GenericFunctionTypeParameterCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/GenericFunctionTypeParameterCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,15 +17,23 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 class GenericFunctionTypeParameterCheckTest {
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test_1() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_312));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/GenericTypeStatementCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/GenericTypeStatementCheckTest.java
index ee660991ad..031f2cf35d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/GenericTypeStatementCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/GenericTypeStatementCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,10 +17,12 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -28,6 +30,12 @@ class GenericTypeStatementCheckTest {
 
   private static final GenericTypeStatementCheck check = new GenericTypeStatementCheck();
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test_1() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_312));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheckTest.java
index d101444787..3288ca62c8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/GenericTypeWithoutArgumentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/GraphQLDenialOfServiceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/GraphQLDenialOfServiceCheckTest.java
index 2886959cbe..9a02015add 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/GraphQLDenialOfServiceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/GraphQLDenialOfServiceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/GroupByIteratorReuseCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/GroupByIteratorReuseCheckTest.java
new file mode 100644
index 0000000000..ff4575d721
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/GroupByIteratorReuseCheckTest.java
@@ -0,0 +1,126 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import java.io.File;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck.PreciseIssue;
+import org.sonar.plugins.python.api.PythonVisitorContext;
+import org.sonar.python.SubscriptionVisitor;
+import org.sonar.python.TestPythonVisitorRunner;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.python.checks.utils.CodeTestUtils.code;
+
+class GroupByIteratorReuseCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/groupByIteratorReuse.py", new GroupByIteratorReuseCheck());
+  }
+
+  @Test
+  void quick_fix_subscript_assignment() {
+    String before = code(
+      "from itertools import groupby",
+      "data = [1, 1, 2, 2, 3]",
+      "groups = {}",
+      "for key, group in groupby(data):",
+      "    groups[key] = group");
+    String after = code(
+      "from itertools import groupby",
+      "data = [1, 1, 2, 2, 3]",
+      "groups = {}",
+      "for key, group in groupby(data):",
+      "    groups[key] = list(group)");
+    GroupByIteratorReuseCheck check = new GroupByIteratorReuseCheck();
+    PythonQuickFixVerifier.verify(check, before, after);
+    PythonQuickFixVerifier.verifyQuickFixMessages(check, before, "Wrap with \"list()\"");
+  }
+
+  @Test
+  void quick_fix_direct_variable_assignment() {
+    String before = code(
+      "from itertools import groupby",
+      "data = [1, 1, 2, 2, 3]",
+      "for key, group in groupby(data):",
+      "    saved = group");
+    String after = code(
+      "from itertools import groupby",
+      "data = [1, 1, 2, 2, 3]",
+      "for key, group in groupby(data):",
+      "    saved = list(group)");
+    PythonQuickFixVerifier.verify(new GroupByIteratorReuseCheck(), before, after);
+  }
+
+  @Test
+  void no_quick_fix_when_multiple_reads_in_loop_body() {
+    GroupByIteratorReuseCheck check = new GroupByIteratorReuseCheck();
+    PythonVisitorContext context = TestPythonVisitorRunner
+      .createContext(new File("src/test/resources/checks/groupByIteratorReuseMultipleReads.py"));
+    SubscriptionVisitor.analyze(Collections.singletonList(check), context);
+
+    // Sort issues by source position to make the test independent of the framework's internal ordering.
+    List issues = context.getIssues().stream()
+      .sorted(Comparator.comparingInt((PreciseIssue i) -> i.primaryLocation().startLine())
+        .thenComparingInt(i -> i.primaryLocation().startLineOffset()))
+      .toList();
+
+    assertThat(issues).hasSize(3);
+    assertThat(issues).extracting(i -> i.primaryLocation().startLine()).containsExactly(12, 13, 14);
+    assertThat(issues).extracting(i -> i.primaryLocation().message())
+      .containsOnly("Consume this group iterator inside the loop, or materialize it into a collection.");
+
+    // See fixture file header for the rationale on why no quickfix is attached.
+    assertThat(issues).allSatisfy(issue -> assertThat(issue.quickFixes()).isEmpty());
+  }
+
+  @Test
+  void no_quick_fix_when_safe_read_follows_unsafe_one() {
+    GroupByIteratorReuseCheck check = new GroupByIteratorReuseCheck();
+    PythonVisitorContext context = TestPythonVisitorRunner
+      .createContext(new File("src/test/resources/checks/groupByIteratorReuseUnsafeWithSafeLaterRead.py"));
+    SubscriptionVisitor.analyze(Collections.singletonList(check), context);
+
+    List issues = context.getIssues();
+    // See fixture file header for the rationale on why no quickfix is attached.
+    assertThat(issues).hasSize(1);
+    assertThat(issues.get(0).quickFixes()).isEmpty();
+  }
+
+  @Test
+  void quick_fix_append_to_list() {
+    String before = code(
+      "from itertools import groupby",
+      "data = [1, 1, 2, 2, 3]",
+      "result = []",
+      "for key, group in groupby(data):",
+      "    result.append(group)");
+    String after = code(
+      "from itertools import groupby",
+      "data = [1, 1, 2, 2, 3]",
+      "result = []",
+      "for key, group in groupby(data):",
+      "    result.append(list(group))");
+    PythonQuickFixVerifier.verify(new GroupByIteratorReuseCheck(), before, after);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/HardcodedCredentialsCallCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/HardcodedCredentialsCallCheckTest.java
index 29cb4d021c..a47f6c854f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/HardcodedCredentialsCallCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/HardcodedCredentialsCallCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/HardcodedIPCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/HardcodedIPCheckTest.java
index 47fc80cff1..c72ac34ea5 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/HardcodedIPCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/HardcodedIPCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,7 +22,13 @@
 class HardcodedIPCheckTest {
 
   @Test
-  void test() {
+  void reports_hardcoded_ips_in_non_test_files() {
     PythonCheckVerifier.verify("src/test/resources/checks/hardcodedIP.py", new HardcodedIPCheck());
   }
+
+  /** Verifies likely test files do not report hardcoded IP addresses. */
+  @Test
+  void skips_likely_test_files() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/hardcodedIPDjango.py", new HardcodedIPCheck());
+  }
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/HashMethodCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/HashMethodCheckTest.java
index 6ac0a7a0c5..ad2a52827a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/HashMethodCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/HashMethodCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/HttpNoContentNonEmptyBodyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/HttpNoContentNonEmptyBodyCheckTest.java
index 4d33d8c6fc..0c531d8011 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/HttpNoContentNonEmptyBodyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/HttpNoContentNonEmptyBodyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IdenticalExpressionOnBinaryOperatorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IdenticalExpressionOnBinaryOperatorCheckTest.java
index 71e81daa92..d9d0907650 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IdenticalExpressionOnBinaryOperatorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IdenticalExpressionOnBinaryOperatorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IdentityComparisonWithCachedTypesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IdentityComparisonWithCachedTypesCheckTest.java
index fdc4fa25fc..6d172cc917 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IdentityComparisonWithCachedTypesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IdentityComparisonWithCachedTypesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IdentityComparisonWithNewObjectCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IdentityComparisonWithNewObjectCheckTest.java
index 14edbeafda..decffb9c6a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IdentityComparisonWithNewObjectCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IdentityComparisonWithNewObjectCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IgnoredParameterCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IgnoredParameterCheckTest.java
index 5c62b3af79..41792b110d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IgnoredParameterCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IgnoredParameterCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IgnoredPureOperationsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IgnoredPureOperationsCheckTest.java
index 936568aaa2..0dc0df8e1d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IgnoredPureOperationsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IgnoredPureOperationsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IgnoredSystemExitCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IgnoredSystemExitCheckTest.java
index c9a1f666aa..32761d0b4a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IgnoredSystemExitCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IgnoredSystemExitCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ImplicitStringConcatenationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ImplicitStringConcatenationCheckTest.java
index d9d4f4433b..60bb06964e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ImplicitStringConcatenationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ImplicitStringConcatenationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IncompatibleOperandsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IncompatibleOperandsCheckTest.java
index e36b34ffe9..44faf109aa 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IncompatibleOperandsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IncompatibleOperandsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IncompleteComparisonMethodsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IncompleteComparisonMethodsCheckTest.java
new file mode 100644
index 0000000000..c653739761
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/IncompleteComparisonMethodsCheckTest.java
@@ -0,0 +1,28 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class IncompleteComparisonMethodsCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/incompleteComparisonMethods.py", new IncompleteComparisonMethodsCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InconsistentTupleReturnCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InconsistentTupleReturnCheckTest.java
new file mode 100644
index 0000000000..50f0773fdc
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/InconsistentTupleReturnCheckTest.java
@@ -0,0 +1,30 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class InconsistentTupleReturnCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/inconsistentTupleReturn.py",
+      new InconsistentTupleReturnCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InconsistentTypeHintCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InconsistentTypeHintCheckTest.java
index f457cfaf98..a965887bcc 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InconsistentTypeHintCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InconsistentTypeHintCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IncorrectExceptionTypeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IncorrectExceptionTypeCheckTest.java
index 9d26b721cd..4be2556116 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IncorrectExceptionTypeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IncorrectExceptionTypeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IncorrectParameterDatetimeConstructorsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IncorrectParameterDatetimeConstructorsCheckTest.java
index 35bcf21027..44e1f777f3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IncorrectParameterDatetimeConstructorsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IncorrectParameterDatetimeConstructorsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IndexMethodCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IndexMethodCheckTest.java
index abec2579b8..cc3beb39dd 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IndexMethodCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IndexMethodCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InefficientDictIterationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InefficientDictIterationCheckTest.java
index fef66f93e4..014b0ff0e1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InefficientDictIterationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InefficientDictIterationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InequalityUsageCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InequalityUsageCheckTest.java
index 334ec907bd..70ea92151a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InequalityUsageCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InequalityUsageCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InfiniteRecursionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InfiniteRecursionCheckTest.java
index 8b8276867f..cd32642fab 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InfiniteRecursionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InfiniteRecursionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InitReturnsValueCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InitReturnsValueCheckTest.java
index 82dfe5b00a..a9f65d489c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InitReturnsValueCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InitReturnsValueCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InputInAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InputInAsyncCheckTest.java
index a4c626118a..a9f508525d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InputInAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InputInAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InstanceAndClassMethodsAtLeastOnePositionalCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InstanceAndClassMethodsAtLeastOnePositionalCheckTest.java
index 1cad8baf73..2260d79566 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InstanceAndClassMethodsAtLeastOnePositionalCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InstanceAndClassMethodsAtLeastOnePositionalCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InstanceMethodSelfAsFirstCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InstanceMethodSelfAsFirstCheckTest.java
index 5999a5e471..9dd7374051 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InstanceMethodSelfAsFirstCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InstanceMethodSelfAsFirstCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InvalidOpenModeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InvalidOpenModeCheckTest.java
index f8fd658991..364ffba3d2 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InvalidOpenModeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InvalidOpenModeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/InvariantReturnCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/InvariantReturnCheckTest.java
index 759b7c5471..23dd487de0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/InvariantReturnCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/InvariantReturnCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IsCloseAbsTolCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IsCloseAbsTolCheckTest.java
index ceb452df2f..65f85c6b4d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IsCloseAbsTolCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IsCloseAbsTolCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ItemOperationsTypeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ItemOperationsTypeCheckTest.java
index fb03bf4091..4909214339 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ItemOperationsTypeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ItemOperationsTypeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IterMethodReturnTypeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IterMethodReturnTypeCheckTest.java
index c647daf34a..b8cfd0a849 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IterMethodReturnTypeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IterMethodReturnTypeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/IterationOnNonIterableCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/IterationOnNonIterableCheckTest.java
index 4695e9f858..6df73f9286 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/IterationOnNonIterableCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/IterationOnNonIterableCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/JumpInFinallyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/JumpInFinallyCheckTest.java
index b1cc661bfa..b29e282a1a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/JumpInFinallyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/JumpInFinallyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/JwtVerificationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/JwtVerificationCheckTest.java
index 1aefe8558e..a28fc0641e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/JwtVerificationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/JwtVerificationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/LambdaAssignmentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/LambdaAssignmentCheckTest.java
index 9442fa00ba..71d4dbdde8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/LambdaAssignmentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/LambdaAssignmentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/LdapAuthenticationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/LdapAuthenticationCheckTest.java
index 625599b34f..543f4c1f5f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/LdapAuthenticationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/LdapAuthenticationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/LineLengthCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/LineLengthCheckTest.java
index 4b217d256f..d843cd7243 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/LineLengthCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/LineLengthCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ListIterableFirstElementCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ListIterableFirstElementCheckTest.java
new file mode 100644
index 0000000000..a429550fa6
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/ListIterableFirstElementCheckTest.java
@@ -0,0 +1,70 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class ListIterableFirstElementCheckTest {
+
+  private static final ListIterableFirstElementCheck check = new ListIterableFirstElementCheck();
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/listIterableFirstElement.py", check);
+  }
+
+  static Stream quickFixTestCases() {
+    return Stream.of(
+      Arguments.of("list(get_users())[0]", "next(iter(get_users()))"),
+      Arguments.of("list(users)[0]", "next(iter(users))"),
+      Arguments.of("list(x for x in range(10))[0]", "next(iter(x for x in range(10)))"),
+      Arguments.of("list(filter(None, items))[0]", "next(iter(filter(None, items)))")
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("quickFixTestCases")
+  void test_quick_fix(String codeWithIssue, String correctCode) {
+    PythonQuickFixVerifier.verify(check, codeWithIssue, correctCode);
+  }
+
+  @Test
+  void test_quick_fix_message() {
+    String codeWithIssue = "list(get_users())[0]";
+
+    PythonQuickFixVerifier.verifyQuickFixMessages(check, codeWithIssue, "Replace with \"next(iter(...))\"");
+  }
+
+  @Test
+  void test_no_quick_fix_multiline_argument_expression() {
+    String codeWithIssue = """
+      list(
+          get_items(
+              arg
+          )
+      )[0]
+      """;
+
+    PythonQuickFixVerifier.verifyNoQuickFixes(check, codeWithIssue);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/LocalVariableAndParameterNameConventionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/LocalVariableAndParameterNameConventionCheckTest.java
index f453db7e85..0773775c23 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/LocalVariableAndParameterNameConventionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/LocalVariableAndParameterNameConventionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/LoggingBestPracticesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/LoggingBestPracticesCheckTest.java
new file mode 100644
index 0000000000..1e35aa629a
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/LoggingBestPracticesCheckTest.java
@@ -0,0 +1,28 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class LoggingBestPracticesCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/loggingBestPractices.py", new LoggingBestPracticesCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/CommandLineArgsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/LoggingExceptionCheckTest.java
similarity index 59%
rename from python-checks/src/test/java/org/sonar/python/checks/hotspots/CommandLineArgsCheckTest.java
rename to python-checks/src/test/java/org/sonar/python/checks/LoggingExceptionCheckTest.java
index 1bfe2376dd..9db91e5d12 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/CommandLineArgsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/LoggingExceptionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,16 +14,17 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-package org.sonar.python.checks.hotspots;
+package org.sonar.python.checks;
 
 import org.junit.jupiter.api.Test;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
-class CommandLineArgsCheckTest {
+class LoggingExceptionCheckTest {
+
+  private final LoggingExceptionCheck check = new LoggingExceptionCheck();
 
   @Test
   void test() {
-    PythonCheckVerifier.verify("src/test/resources/checks/hotspots/commandLineArgs.py", new CommandLineArgsCheck());
+    PythonCheckVerifier.verify("src/test/resources/checks/loggingException.py", check);
   }
-
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/LongIntegerWithLowercaseSuffixUsageCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/LongIntegerWithLowercaseSuffixUsageCheckTest.java
index 52cd95b598..681fbc9286 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/LongIntegerWithLowercaseSuffixUsageCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/LongIntegerWithLowercaseSuffixUsageCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/LoopExecutingAtMostOnceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/LoopExecutingAtMostOnceCheckTest.java
index ef2525cd4a..07f3bd454e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/LoopExecutingAtMostOnceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/LoopExecutingAtMostOnceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/LoopOverDictKeyValuesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/LoopOverDictKeyValuesCheckTest.java
index cab2bf9e4d..b876bb1d9a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/LoopOverDictKeyValuesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/LoopOverDictKeyValuesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MandatoryFunctionParameterTypeHintCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MandatoryFunctionParameterTypeHintCheckTest.java
index 53d8f9c89a..754e5efc74 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/MandatoryFunctionParameterTypeHintCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/MandatoryFunctionParameterTypeHintCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MandatoryFunctionReturnTypeHintCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MandatoryFunctionReturnTypeHintCheckTest.java
index 387bd5074f..0696e44af6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/MandatoryFunctionReturnTypeHintCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/MandatoryFunctionReturnTypeHintCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -242,6 +242,19 @@ void no_quick_fix_generic_types() {
     PythonQuickFixVerifier.verifyNoQuickFixes(check, codeWithIssue);
   }
 
+  @Test
+  void no_quick_fix_mixed_supported_and_unsupported_return_types() {
+    String codeWithIssue = code(
+      "class Foo:",
+      "    pass",
+      "def foo(condition: bool):",
+      "    if condition:",
+      "        return 42",
+      "    return Foo()");
+    MandatoryFunctionReturnTypeHintCheck check = new MandatoryFunctionReturnTypeHintCheck();
+    PythonQuickFixVerifier.verifyNoQuickFixes(check, codeWithIssue);
+  }
+
   @Test
   void no_quick_fix_ambiguous_type() {
     String codeWithIssue = code(
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MembershipTestSupportCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MembershipTestSupportCheckTest.java
index 643ce873d6..0d6f310b08 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/MembershipTestSupportCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/MembershipTestSupportCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MethodNameCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MethodNameCheckTest.java
index fb71edbf55..389586e3d1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/MethodNameCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/MethodNameCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MethodShouldBeStaticCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MethodShouldBeStaticCheckTest.java
index 3dc1613ee0..dc8377ef53 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/MethodShouldBeStaticCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/MethodShouldBeStaticCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MissingDocstringCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MissingDocstringCheckTest.java
index 3eb2246859..bf497c0241 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/MissingDocstringCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/MissingDocstringCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MissingHyperParameterCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MissingHyperParameterCheckTest.java
index d59a74545b..988c64ff5d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/MissingHyperParameterCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/MissingHyperParameterCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MissingNewlineAtEndOfFileCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MissingNewlineAtEndOfFileCheckTest.java
index cd55ef6c31..08996aae6e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/MissingNewlineAtEndOfFileCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/MissingNewlineAtEndOfFileCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ModifiedParameterValueCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ModifiedParameterValueCheckTest.java
index 9403fd0ef8..d83bff4ee4 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ModifiedParameterValueCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ModifiedParameterValueCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ModuleNameCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ModuleNameCheckTest.java
index 9f6732c3b2..10b6e34045 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ModuleNameCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ModuleNameCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MultipleInheritanceMROConflictCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MultipleInheritanceMROConflictCheckTest.java
new file mode 100644
index 0000000000..c25ad656ae
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/MultipleInheritanceMROConflictCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class MultipleInheritanceMROConflictCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/multipleInheritanceMROConflict.py", new MultipleInheritanceMROConflictCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/MutableDefaultValueCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/MutableDefaultValueCheckTest.java
new file mode 100644
index 0000000000..2d0fbb9f5e
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/MutableDefaultValueCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class MutableDefaultValueCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/mutableDefaultValueCheck.py", new MutableDefaultValueCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NeedlessPassCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NeedlessPassCheckTest.java
index 2f36931102..5b64cb7b86 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NeedlessPassCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NeedlessPassCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NestedCollectionsCreationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NestedCollectionsCreationCheckTest.java
index b009b2b17a..09f2d7b375 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NestedCollectionsCreationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NestedCollectionsCreationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NestedConditionalExpressionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NestedConditionalExpressionCheckTest.java
index c54df288e1..07f7ef777e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NestedConditionalExpressionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NestedConditionalExpressionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NestedControlFlowDepthCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NestedControlFlowDepthCheckTest.java
index 973425dc2e..d04156526a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NestedControlFlowDepthCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NestedControlFlowDepthCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NestedLoopVariableReuseCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NestedLoopVariableReuseCheckTest.java
new file mode 100644
index 0000000000..8fb6458fe7
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/NestedLoopVariableReuseCheckTest.java
@@ -0,0 +1,30 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class NestedLoopVariableReuseCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/nestedLoopVariableReuse.py",
+      new NestedLoopVariableReuseCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NewStyleClassCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NewStyleClassCheckTest.java
index abd08a402b..84701dcb83 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NewStyleClassCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NewStyleClassCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NoPersonReferenceInTodoCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NoPersonReferenceInTodoCheckTest.java
index 8318031d02..93fc726894 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NoPersonReferenceInTodoCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NoPersonReferenceInTodoCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NoQaCommentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NoQaCommentCheckTest.java
index a50ea6cc71..4883f6bb35 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NoQaCommentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NoQaCommentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NoReRaiseInExitCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NoReRaiseInExitCheckTest.java
index b2d28cdd48..75758831b3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NoReRaiseInExitCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NoReRaiseInExitCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NoSonarCommentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NoSonarCommentCheckTest.java
index 98cdce0b78..ac37ed5dcd 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NoSonarCommentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NoSonarCommentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NoSonarCommentFormatCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NoSonarCommentFormatCheckTest.java
index 645319a632..6d13dd573c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NoSonarCommentFormatCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NoSonarCommentFormatCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NonCallableCalledCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NonCallableCalledCheckTest.java
index d6faa46328..a0442c92fb 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NonCallableCalledCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NonCallableCalledCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NonSingletonTfVariableCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NonSingletonTfVariableCheckTest.java
index bde7005f81..5294af3cb0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NonSingletonTfVariableCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NonSingletonTfVariableCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NonStringInAllPropertyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NonStringInAllPropertyCheckTest.java
index 7d0e0979d4..4ec2394309 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NonStringInAllPropertyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NonStringInAllPropertyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NotImplementedBooleanContextCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NotImplementedBooleanContextCheckTest.java
index 9d7dbc5a78..b093f3611a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NotImplementedBooleanContextCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NotImplementedBooleanContextCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,15 +17,23 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 class NotImplementedBooleanContextCheckTest {
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_314));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NotImplementedErrorInOperatorMethodsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NotImplementedErrorInOperatorMethodsCheckTest.java
index 03b0eeb3ba..28a093ed72 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NotImplementedErrorInOperatorMethodsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NotImplementedErrorInOperatorMethodsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NumpyIsNanCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NumpyIsNanCheckTest.java
index 82d4a6a7e8..bd38fa16b8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NumpyIsNanCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NumpyIsNanCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NumpyListOverGeneratorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NumpyListOverGeneratorCheckTest.java
index 571848e84f..64c263e034 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NumpyListOverGeneratorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NumpyListOverGeneratorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NumpyRandomStateCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NumpyRandomStateCheckTest.java
index 471d6aa8d7..ca941ef7ba 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NumpyRandomStateCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NumpyRandomStateCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NumpyWeekMaskValidationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NumpyWeekMaskValidationCheckTest.java
index 3e2173243e..7f107b69d1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NumpyWeekMaskValidationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NumpyWeekMaskValidationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/NumpyWhereOneConditionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/NumpyWhereOneConditionCheckTest.java
index fa2ae4dbe2..4a9077a31f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/NumpyWhereOneConditionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/NumpyWhereOneConditionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/OneStatementPerLineCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/OneStatementPerLineCheckTest.java
index a22a04a084..78750ed8b0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/OneStatementPerLineCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/OneStatementPerLineCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/OpenSourceCheckListTest.java b/python-checks/src/test/java/org/sonar/python/checks/OpenSourceCheckListTest.java
index 2d041e98b9..4103d0ee99 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/OpenSourceCheckListTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/OpenSourceCheckListTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -24,7 +24,6 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Set;
 import java.util.regex.Matcher;
@@ -82,7 +81,7 @@ void test() {
   void validate_sqKey_field_in_json() throws IOException {
     try (Stream fileStream = Files.find(METADATA_DIR, 1, (path, attr) -> path.toString().endsWith(".json"))) {
       List jsonList = fileStream
-        .filter(path -> !path.toString().endsWith("Sonar_way_profile.json"))
+        .filter(path -> !path.toString().endsWith("_profile.json"))
         .sorted()
         .toList();
 
@@ -108,7 +107,7 @@ void test_no_deprecated_rule_in_default_profile() throws IOException, ParseExcep
       List keysInDefaultProfile = getKeysInDefaultProfile(sonarWayProfilePath);
 
       Set deprecatedKeys = jsonList.stream()
-        .filter(path -> !path.toString().endsWith("Sonar_way_profile.json"))
+        .filter(path -> !path.toString().endsWith("_profile.json"))
         .filter(path1 -> {
           try {
             return isDeprecated(path1);
@@ -132,10 +131,18 @@ void test_no_deprecated_rule_in_default_profile() throws IOException, ParseExcep
   void test_locally_deprecated_rules_stay_deprecated() throws IOException {
     // Some rules have been deprecated only for Python. When executed, rule-api reverts those rule to "ready" status, which is incorrect.
     // This test is here to ensure it doesn't happen.
-    List locallyDeprecatedRules = Arrays.asList("S1523", "S4721");
+    List locallyDeprecatedRules = List.of(
+            "S1721",
+            "S2733",
+            "S5439",
+            "S5042",
+            "S1717",
+            "S4828",
+            "ClassComplexity",
+            "FileComplexity");
     try (Stream fileStream = Files.find(METADATA_DIR, 1, (path, attr) -> path.toString().endsWith(".json"))) {
       Set deprecatedKeys = fileStream
-        .filter(path -> !path.toString().endsWith("Sonar_way_profile.json"))
+        .filter(path -> !path.toString().endsWith("_profile.json"))
         .filter(path1 -> {
           try {
             return isDeprecated(path1);
diff --git a/python-checks/src/test/java/org/sonar/python/checks/OverwrittenCollectionEntryCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/OverwrittenCollectionEntryCheckTest.java
index ef103f2403..54ce16db19 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/OverwrittenCollectionEntryCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/OverwrittenCollectionEntryCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PandasAddMergeParametersCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PandasAddMergeParametersCheckTest.java
index 53ac33faa0..52797365d1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PandasAddMergeParametersCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PandasAddMergeParametersCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PandasChainInstructionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PandasChainInstructionCheckTest.java
index e7043bbf62..de8980064c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PandasChainInstructionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PandasChainInstructionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PandasDataFrameToNumpyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PandasDataFrameToNumpyCheckTest.java
index e9e40ccc3f..c9bef482aa 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PandasDataFrameToNumpyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PandasDataFrameToNumpyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PandasModifyInPlaceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PandasModifyInPlaceCheckTest.java
index b56a77f031..b937ccf30c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PandasModifyInPlaceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PandasModifyInPlaceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PandasReadNoDataTypeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PandasReadNoDataTypeCheckTest.java
index 86195dd9f1..4761f75985 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PandasReadNoDataTypeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PandasReadNoDataTypeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PandasToDatetimeFormatCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PandasToDatetimeFormatCheckTest.java
index e774a76503..67971435f3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PandasToDatetimeFormatCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PandasToDatetimeFormatCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ParsingErrorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ParsingErrorCheckTest.java
index c03fa289f7..9c4ea974e8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ParsingErrorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ParsingErrorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PreIncrementDecrementCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PreIncrementDecrementCheckTest.java
index 645007f8c8..cb0a566fc3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PreIncrementDecrementCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PreIncrementDecrementCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PredictableSaltCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PredictableSaltCheckTest.java
index d07555e666..28767e14fe 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PredictableSaltCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PredictableSaltCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PrintStatementUsageCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PrintStatementUsageCheckTest.java
index 503c394260..2a1f756aac 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PrintStatementUsageCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PrintStatementUsageCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PropertyAccessorParameterCountCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PropertyAccessorParameterCountCheckTest.java
index 50c23d5032..a2702b765d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PropertyAccessorParameterCountCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PropertyAccessorParameterCountCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PropertyMethodWithoutReturnCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PropertyMethodWithoutReturnCheckTest.java
new file mode 100644
index 0000000000..50be609af8
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/PropertyMethodWithoutReturnCheckTest.java
@@ -0,0 +1,33 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class PropertyMethodWithoutReturnCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/propertyMethodWithoutReturn.py", new PropertyMethodWithoutReturnCheck());
+  }
+
+  @Test
+  void test_shadowing_propery() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/propertyMethodWithoutReturnShadowingProperty.py", new PropertyMethodWithoutReturnCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PyTorchDataLoaderNumWorkersCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PyTorchDataLoaderNumWorkersCheckTest.java
index 217c0bc1f4..78e563a9bd 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PyTorchDataLoaderNumWorkersCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PyTorchDataLoaderNumWorkersCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PydanticConfigDictValidationOptionsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PydanticConfigDictValidationOptionsCheckTest.java
new file mode 100644
index 0000000000..e4fa2f9ca4
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/PydanticConfigDictValidationOptionsCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class PydanticConfigDictValidationOptionsCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/pydanticConfigDictValidationOptions.py", new PydanticConfigDictValidationOptionsCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DynamicCodeExecutionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PydanticCoreSerializationFallbackCheckTest.java
similarity index 58%
rename from python-checks/src/test/java/org/sonar/python/checks/hotspots/DynamicCodeExecutionCheckTest.java
rename to python-checks/src/test/java/org/sonar/python/checks/PydanticCoreSerializationFallbackCheckTest.java
index dc70ac8c1c..c4e5e01842 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DynamicCodeExecutionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PydanticCoreSerializationFallbackCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,16 +14,17 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-package org.sonar.python.checks.hotspots;
+package org.sonar.python.checks;
 
 import org.junit.jupiter.api.Test;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
-class DynamicCodeExecutionCheckTest {
-
+class PydanticCoreSerializationFallbackCheckTest {
   @Test
   void test() {
-    PythonCheckVerifier.verify("src/test/resources/checks/hotspots/dynamicCodeExecution.py", new DynamicCodeExecutionCheck());
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/pydanticCoreSerializationFallback.py",
+      new PydanticCoreSerializationFallbackCheck()
+    );
   }
-
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PydanticDataclassRevalidationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PydanticDataclassRevalidationCheckTest.java
new file mode 100644
index 0000000000..cdd5ae2026
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/PydanticDataclassRevalidationCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class PydanticDataclassRevalidationCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/pydanticDataclassRevalidation.py", new PydanticDataclassRevalidationCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketServerEncryptionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PydanticDoubleUnderscorePrivateAttributeCheckTest.java
similarity index 58%
rename from python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketServerEncryptionCheckTest.java
rename to python-checks/src/test/java/org/sonar/python/checks/PydanticDoubleUnderscorePrivateAttributeCheckTest.java
index 9cea57590e..37937f090e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketServerEncryptionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PydanticDoubleUnderscorePrivateAttributeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,16 +14,16 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-package org.sonar.python.checks.cdk;
+package org.sonar.python.checks;
 
 import org.junit.jupiter.api.Test;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
-class S3BucketServerEncryptionCheckTest {
+class PydanticDoubleUnderscorePrivateAttributeCheckTest {
 
   @Test
   void test() {
-    PythonCheckVerifier.verify("src/test/resources/checks/cdk/s3BucketServerEncryption.py", new S3BucketServerEncryptionCheck());
+    PythonCheckVerifier.verify("src/test/resources/checks/pydanticDoubleUnderscorePrivateAttribute.py", new PydanticDoubleUnderscorePrivateAttributeCheck());
   }
 
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PydanticFieldValidatorReturnCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PydanticFieldValidatorReturnCheckTest.java
new file mode 100644
index 0000000000..415ae4031b
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/PydanticFieldValidatorReturnCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class PydanticFieldValidatorReturnCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/pydanticFieldValidatorReturn.py", new PydanticFieldValidatorReturnCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PydanticJsonSchemaInputTypeWithAfterModeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PydanticJsonSchemaInputTypeWithAfterModeCheckTest.java
new file mode 100644
index 0000000000..8ef1904977
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/PydanticJsonSchemaInputTypeWithAfterModeCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class PydanticJsonSchemaInputTypeWithAfterModeCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/pydanticJsonSchemaInputTypeWithAfterMode.py", new PydanticJsonSchemaInputTypeWithAfterModeCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PydanticMultipleInheritanceConfigCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PydanticMultipleInheritanceConfigCheckTest.java
new file mode 100644
index 0000000000..ebd020911c
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/PydanticMultipleInheritanceConfigCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class PydanticMultipleInheritanceConfigCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/pydanticMultipleInheritanceConfigCheck.py", new PydanticMultipleInheritanceConfigCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PydanticOptionalFieldDefaultCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PydanticOptionalFieldDefaultCheckTest.java
index fa77b0a347..657d1d2bac 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PydanticOptionalFieldDefaultCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PydanticOptionalFieldDefaultCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PydanticSkipValidationWithConstraintsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PydanticSkipValidationWithConstraintsCheckTest.java
new file mode 100644
index 0000000000..7931bfaa97
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/PydanticSkipValidationWithConstraintsCheckTest.java
@@ -0,0 +1,31 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class PydanticSkipValidationWithConstraintsCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/pydanticSkipValidationWithConstraints.py",
+      new PydanticSkipValidationWithConstraintsCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PytzTimeZoneInDatetimeConstructorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PytzTimeZoneInDatetimeConstructorCheckTest.java
index 02c9fcf95c..7eb6ea699e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PytzTimeZoneInDatetimeConstructorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PytzTimeZoneInDatetimeConstructorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/PytzUsageCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/PytzUsageCheckTest.java
index 96ff89470f..6aa1c9e5c5 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/PytzUsageCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/PytzUsageCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,12 +17,21 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 class PytzUsageCheckTest {
+
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test_39_310_311_312() {
     ProjectPythonVersion
diff --git a/python-checks/src/test/java/org/sonar/python/checks/RaiseOutsideExceptCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/RaiseOutsideExceptCheckTest.java
index 1806908fef..07372d9ecd 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/RaiseOutsideExceptCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/RaiseOutsideExceptCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/RandomSeedCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/RandomSeedCheckTest.java
index 9d3b812ee0..096d297998 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/RandomSeedCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/RandomSeedCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/RedundantJumpCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/RedundantJumpCheckTest.java
index 96016d200b..e88a96090d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/RedundantJumpCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/RedundantJumpCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ReferencedBeforeAssignmentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ReferencedBeforeAssignmentCheckTest.java
index 5482c2df0d..19fc832f7d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ReferencedBeforeAssignmentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ReferencedBeforeAssignmentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ReturnAndYieldInOneFunctionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ReturnAndYieldInOneFunctionCheckTest.java
index 7cace1bcb2..1aa7c5a125 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ReturnAndYieldInOneFunctionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ReturnAndYieldInOneFunctionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ReturnYieldOutsideFunctionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ReturnYieldOutsideFunctionCheckTest.java
index d0d3a60257..c1162c341d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ReturnYieldOutsideFunctionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ReturnYieldOutsideFunctionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/RewriteCollectionConstructorAsComprehensionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/RewriteCollectionConstructorAsComprehensionCheckTest.java
index 7acfdecc1b..20a42c2a5b 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/RewriteCollectionConstructorAsComprehensionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/RewriteCollectionConstructorAsComprehensionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/RobustCipherAlgorithmCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/RobustCipherAlgorithmCheckTest.java
index 1d90030ecb..941a0d6de4 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/RobustCipherAlgorithmCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/RobustCipherAlgorithmCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/RouterPrefixInIncludeRouterCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/RouterPrefixInIncludeRouterCheckTest.java
index 0f3663509b..b79bbed012 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/RouterPrefixInIncludeRouterCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/RouterPrefixInIncludeRouterCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SameBranchCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SameBranchCheckTest.java
index b4307d5b4e..55b7d3df11 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SameBranchCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SameBranchCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SameConditionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SameConditionCheckTest.java
index 036b02ca27..a490081f3c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SameConditionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SameConditionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SecureModeEncryptionAlgorithmsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SecureModeEncryptionAlgorithmsCheckTest.java
index 993df1ac90..2f4848ca50 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SecureModeEncryptionAlgorithmsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SecureModeEncryptionAlgorithmsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SelfAssignmentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SelfAssignmentCheckTest.java
index 1b1ea6e245..5ab04b06c3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SelfAssignmentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SelfAssignmentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SetDiscardOverRemoveCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SetDiscardOverRemoveCheckTest.java
new file mode 100644
index 0000000000..6c7dd87b32
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/SetDiscardOverRemoveCheckTest.java
@@ -0,0 +1,38 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class SetDiscardOverRemoveCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/setDiscardOverRemove.py", new SetDiscardOverRemoveCheck());
+  }
+
+  @Test
+  void quickFixTest() {
+    String before = "my_set = {1, 2, 3}\nif x in my_set:\n    my_set.remove(x)\n";
+    String after = "my_set = {1, 2, 3}\nmy_set.discard(x)";
+    var check = new SetDiscardOverRemoveCheck();
+    PythonQuickFixVerifier.verify(check, before, after);
+    PythonQuickFixVerifier.verifyQuickFixMessages(check, before, "Replace with \"discard()\"");
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SetDuplicateKeyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SetDuplicateKeyCheckTest.java
index 1fab1f34f9..7bd41f569e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SetDuplicateKeyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SetDuplicateKeyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SetUpdateOverForLoopCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SetUpdateOverForLoopCheckTest.java
new file mode 100644
index 0000000000..c07c2dcc0e
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/SetUpdateOverForLoopCheckTest.java
@@ -0,0 +1,78 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class SetUpdateOverForLoopCheckTest {
+
+  private static final SetUpdateOverForLoopCheck check = new SetUpdateOverForLoopCheck();
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/setUpdateOverForLoop.py", check);
+  }
+
+  @Test
+  void test_quick_fix() {
+    String codeWithIssue = """
+      my_set = set()
+      other_collection = [4, 5, 6]
+      for element in other_collection:
+          my_set.add(element)
+      """;
+
+    PythonQuickFixVerifier.verifyQuickFixMessages(check, codeWithIssue, "Use \"set.update()\" instead");
+
+    String correctCode = """
+      my_set = set()
+      other_collection = [4, 5, 6]
+      my_set.update(other_collection)""";
+
+    PythonQuickFixVerifier.verify(check, codeWithIssue, correctCode);
+  }
+
+  @Test
+  void test_no_quick_fix_on_multiline_iterable() {
+    String codeWithIssue = """
+      my_set = set()
+      for element in [
+          1,
+          2,
+          3,
+      ]:
+          my_set.add(element)
+      """;
+
+    PythonQuickFixVerifier.verifyNoQuickFixes(check, codeWithIssue);
+  }
+
+  @Test
+  void test_no_quick_fix_on_multiline_receiver() {
+    String codeWithIssue = """
+      my_set = set()
+      items = [1, 2, 3]
+      for element in items:
+          (my_set
+           ).add(element)
+      """;
+
+    PythonQuickFixVerifier.verifyNoQuickFixes(check, codeWithIssue);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SideEffectInTfFunctionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SideEffectInTfFunctionCheckTest.java
index f301044f85..551005d24c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SideEffectInTfFunctionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SideEffectInTfFunctionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SillyEqualityCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SillyEqualityCheckTest.java
index 9a92bdab1e..3700dd9b9c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SillyEqualityCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SillyEqualityCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SillyIdentityCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SillyIdentityCheckTest.java
index f3283c860e..373d3ba258 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SillyIdentityCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SillyIdentityCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SingleDispatchMixupCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SingleDispatchMixupCheckTest.java
new file mode 100644
index 0000000000..77bd24569f
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/SingleDispatchMixupCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class SingleDispatchMixupCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/singleDispatchMixup.py", new SingleDispatchMixupCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SkLearnEstimatorDontInitializeEstimatedValuesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SkLearnEstimatorDontInitializeEstimatedValuesCheckTest.java
index db813cd180..666128c221 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SkLearnEstimatorDontInitializeEstimatedValuesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SkLearnEstimatorDontInitializeEstimatedValuesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SklearnCachedPipelineDontAccessTransformersCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SklearnCachedPipelineDontAccessTransformersCheckTest.java
index 95a82629a6..e0b5c0e632 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SklearnCachedPipelineDontAccessTransformersCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SklearnCachedPipelineDontAccessTransformersCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SklearnPipelineParameterAreCorrectCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SklearnPipelineParameterAreCorrectCheckTest.java
index e8fbd49529..c6a646df38 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SklearnPipelineParameterAreCorrectCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SklearnPipelineParameterAreCorrectCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SklearnPipelineSpecifyMemoryArgumentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SklearnPipelineSpecifyMemoryArgumentCheckTest.java
index 6ac55b48ce..acf145a595 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SklearnPipelineSpecifyMemoryArgumentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SklearnPipelineSpecifyMemoryArgumentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SleepZeroInAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SleepZeroInAsyncCheckTest.java
index 8bb0da705e..3045109d16 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SleepZeroInAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SleepZeroInAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SlotsAssignmentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SlotsAssignmentCheckTest.java
new file mode 100644
index 0000000000..690d83084e
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/SlotsAssignmentCheckTest.java
@@ -0,0 +1,28 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class SlotsAssignmentCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/slotsAssignment.py", new SlotsAssignmentCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SortedMinMaxCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SortedMinMaxCheckTest.java
new file mode 100644
index 0000000000..9a93ed6ef1
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/SortedMinMaxCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class SortedMinMaxCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/sortedMinMax.py", new SortedMinMaxCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SpecialMethodParamListCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SpecialMethodParamListCheckTest.java
index 243d69769c..6d3f6883cf 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SpecialMethodParamListCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SpecialMethodParamListCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SpecialMethodReturnTypeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SpecialMethodReturnTypeCheckTest.java
index ed0a360bb0..044cb6cfd6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SpecialMethodReturnTypeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SpecialMethodReturnTypeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/StartsWithEndsWithTupleCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/StartsWithEndsWithTupleCheckTest.java
new file mode 100644
index 0000000000..274c1bb7f6
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/StartsWithEndsWithTupleCheckTest.java
@@ -0,0 +1,135 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class StartsWithEndsWithTupleCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/startsWithEndsWithTupleCheck.py", new StartsWithEndsWithTupleCheck());
+  }
+
+  static Stream quickFixTestCases() {
+    return Stream.of(
+      Arguments.of(
+        """
+          s = "https://example.com"
+          s.startswith("http://") or s.startswith("https://")
+          """,
+        """
+          s = "https://example.com"
+          s.startswith(("http://", "https://"))
+          """,
+        "Replace with a single call using a tuple argument"),
+      Arguments.of(
+        """
+          filename = "photo.jpg"
+          filename.endswith(".jpg") or filename.endswith(".png")
+          """,
+        """
+          filename = "photo.jpg"
+          filename.endswith((".jpg", ".png"))
+          """,
+        "Replace with a single call using a tuple argument"),
+      Arguments.of(
+        """
+          data = b"hello world"
+          data.startswith(b"hello") or data.startswith(b"hi")
+          """,
+        """
+          data = b"hello world"
+          data.startswith((b"hello", b"hi"))
+          """,
+        "Replace with a single call using a tuple argument"),
+      Arguments.of(
+        """
+          paths = ["/usr/bin", "/etc/conf"]
+          paths[0].startswith("/usr") or paths[0].startswith("/etc")
+          """,
+        """
+          paths = ["/usr/bin", "/etc/conf"]
+          paths[0].startswith(("/usr", "/etc"))
+          """,
+        "Replace with a single call using a tuple argument"),
+      Arguments.of(
+        """
+          filename = "report.pdf"
+          filename.endswith(".pdf") or filename.endswith(".doc") or filename.endswith(".txt")
+          """,
+        """
+          filename = "report.pdf"
+          filename.endswith((".pdf", ".doc", ".txt"))
+          """,
+        "Replace with a single call using a tuple argument"),
+      Arguments.of(
+        """
+          class MyClass:
+              def check(self):
+                  self.name.startswith("a") or self.name.startswith("b")
+          """,
+        """
+          class MyClass:
+              def check(self):
+                  self.name.startswith(("a", "b"))
+          """,
+        "Replace with a single call using a tuple argument"),
+      Arguments.of(
+        """
+          s = "https://example.com"
+          if (s.startswith("http://")
+                  or s.startswith("https://")):
+              pass
+          """,
+        """
+          s = "https://example.com"
+          if (s.startswith(("http://", "https://"))):
+              pass
+          """,
+        "Replace with a single call using a tuple argument"),
+      Arguments.of(
+        """
+          s = "https://example.com"
+          if s.startswith("http://") \\
+                  or s.startswith("https://"):
+              pass
+          """,
+        """
+          s = "https://example.com"
+          if s.startswith(("http://", "https://")):
+              pass
+          """,
+        "Replace with a single call using a tuple argument")
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("quickFixTestCases")
+  void testQuickFix(String before, String after, String expectedMessage) {
+    var check = new StartsWithEndsWithTupleCheck();
+    PythonQuickFixVerifier.verify(check, before, after);
+    PythonQuickFixVerifier.verifyQuickFixMessages(check, before, expectedMessage);
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/StopIterationInGeneratorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/StopIterationInGeneratorCheckTest.java
new file mode 100644
index 0000000000..8c824a3177
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/StopIterationInGeneratorCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class StopIterationInGeneratorCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/stopIterationInGenerator.py", new StopIterationInGeneratorCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/StrftimeConfusingHourSystemCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/StrftimeConfusingHourSystemCheckTest.java
index c80b656c5b..8876eebca8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/StrftimeConfusingHourSystemCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/StrftimeConfusingHourSystemCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/StringFormatCorrectnessCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/StringFormatCorrectnessCheckTest.java
index 1ec07391d2..2c139129d1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/StringFormatCorrectnessCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/StringFormatCorrectnessCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,13 +16,57 @@
  */
 package org.sonar.python.checks;
 
+import java.lang.reflect.Method;
+import java.util.Optional;
 import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.tree.ArgList;
+import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.RegularArgument;
+import org.sonar.plugins.python.api.tree.StringLiteral;
+import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
 class StringFormatCorrectnessCheckTest {
 
   @Test
   void test() {
     PythonCheckVerifier.verify("src/test/resources/checks/stringFormatCorrectness.py", new StringFormatCorrectnessCheck());
   }
+
+  @Test
+  void enclosing_call_expression_returns_empty_when_regular_argument_parent_is_not_arg_list() throws Exception {
+    StringLiteral literal = mock(StringLiteral.class);
+    RegularArgument argument = mock(RegularArgument.class);
+    Tree nonArgListParent = mock(Tree.class);
+
+    when(literal.parent()).thenReturn(argument);
+    when(argument.parent()).thenReturn(nonArgListParent);
+
+    assertThat(invokeEnclosingCallExpression(literal)).isEmpty();
+  }
+
+  @Test
+  void enclosing_call_expression_returns_empty_when_arg_list_parent_is_not_call_expression() throws Exception {
+    StringLiteral literal = mock(StringLiteral.class);
+    RegularArgument argument = mock(RegularArgument.class);
+    ArgList argList = mock(ArgList.class);
+    Tree nonCallParent = mock(Tree.class);
+
+    when(literal.parent()).thenReturn(argument);
+    when(argument.parent()).thenReturn(argList);
+    when(argList.parent()).thenReturn(nonCallParent);
+
+    assertThat(invokeEnclosingCallExpression(literal)).isEmpty();
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Optional invokeEnclosingCallExpression(StringLiteral literal) throws Exception {
+    Method method = StringFormatCorrectnessCheck.class.getDeclaredMethod("enclosingCallExpression", StringLiteral.class);
+    method.setAccessible(true);
+    return (Optional) method.invoke(null, literal);
+  }
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/StringFormatMisuseCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/StringFormatMisuseCheckTest.java
index b189c7c530..9f112e78f7 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/StringFormatMisuseCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/StringFormatMisuseCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/StringLiteralDuplicationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/StringLiteralDuplicationCheckTest.java
index 713de8d3ba..4074a63236 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/StringLiteralDuplicationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/StringLiteralDuplicationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,10 +17,11 @@
 package org.sonar.python.checks;
 
 import org.assertj.core.api.Assertions;
-import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 class StringLiteralDuplicationCheckTest {
 
   @Test
@@ -33,6 +34,22 @@ void test_no_issue_on_test_code() {
     PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/test_stringLiteralDuplication.py", new StringLiteralDuplicationCheck());
   }
 
+  @Test
+  void test_no_issue_on_django_generated_migration() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/django/migrations/0001_generated_migration.py", new StringLiteralDuplicationCheck());
+  }
+
+  @Test
+  void test_no_issue_on_protobuf_generated_code() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/generated/user_pb2.py", new StringLiteralDuplicationCheck());
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/generated/user_pb2_grpc.py", new StringLiteralDuplicationCheck());
+  }
+
+  @Test
+  void test_issue_on_protobuf_suffix_near_match() {
+    PythonCheckVerifier.verify("src/test/resources/checks/generated/stringLiteralDuplication_pb2_test.py", new StringLiteralDuplicationCheck());
+  }
+
   @Test
   void test_custom_pattern() {
     StringLiteralDuplicationCheck check = new StringLiteralDuplicationCheck();
@@ -44,7 +61,7 @@ void test_custom_pattern() {
   void test_invalid_custom_pattern() {
     StringLiteralDuplicationCheck check = new StringLiteralDuplicationCheck();
     check.customExclusionRegex = "a+*(";
-    IllegalStateException e = Assert.assertThrows(IllegalStateException.class,
+    IllegalStateException e = assertThrows(IllegalStateException.class,
       () -> PythonCheckVerifier.verify("src/test/resources/checks/stringLiteralDuplicationCustom.py", check));
     Assertions.assertThat(e.getMessage()).isEqualTo("Unable to compile regular expression: a+*(");
 
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SumListConcatenationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SumListConcatenationCheckTest.java
new file mode 100644
index 0000000000..015e977219
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/SumListConcatenationCheckTest.java
@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class SumListConcatenationCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/sumListConcatenation.py", new SumListConcatenationCheck());
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SynchronousFileOperationsInAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SynchronousFileOperationsInAsyncCheckTest.java
index 6fe45b1d08..16d3326cb3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SynchronousFileOperationsInAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SynchronousFileOperationsInAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SynchronousHttpOperationsInAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SynchronousHttpOperationsInAsyncCheckTest.java
index 5c8f05749d..a87e278fea 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SynchronousHttpOperationsInAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SynchronousHttpOperationsInAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SynchronousOsCallsInAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SynchronousOsCallsInAsyncCheckTest.java
index 628c2d23ac..b00d27eb06 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SynchronousOsCallsInAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SynchronousOsCallsInAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/SynchronousSubprocessOperationsInAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/SynchronousSubprocessOperationsInAsyncCheckTest.java
index 7e9682cd43..d28a551105 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/SynchronousSubprocessOperationsInAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/SynchronousSubprocessOperationsInAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TaskGroupNurseryUsedOnlyOnceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TaskGroupNurseryUsedOnlyOnceCheckTest.java
index 7c00b043f0..77b66635b5 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TaskGroupNurseryUsedOnlyOnceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TaskGroupNurseryUsedOnlyOnceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TempFileCreationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TempFileCreationCheckTest.java
index acc9e877c1..8f3df2d622 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TempFileCreationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TempFileCreationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TemplateAndStrConcatenationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TemplateAndStrConcatenationCheckTest.java
index f234930ed1..52f86348f9 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TemplateAndStrConcatenationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TemplateAndStrConcatenationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,15 +17,23 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 class TemplateAndStrConcatenationCheckTest {
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_314));
@@ -39,4 +47,3 @@ void test_older_python_version() {
     assertThat(issues).isEmpty();
   }
 }
-
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TemplateStringStructuralPatternMatchingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TemplateStringStructuralPatternMatchingCheckTest.java
index f8384d5920..837e5c90c3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TemplateStringStructuralPatternMatchingCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TemplateStringStructuralPatternMatchingCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,15 +17,23 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 class TemplateStringStructuralPatternMatchingCheckTest {
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_314));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TestClientContentParameterCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TestClientContentParameterCheckTest.java
index 9aed519c6a..d400bebbfb 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TestClientContentParameterCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TestClientContentParameterCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TfFunctionDependOnOutsideVariableCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TfFunctionDependOnOutsideVariableCheckTest.java
index ee5372ac34..a50fa70b4d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TfFunctionDependOnOutsideVariableCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TfFunctionDependOnOutsideVariableCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TfFunctionRecursivityCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TfFunctionRecursivityCheckTest.java
index 4645432c89..d7bdbd8cb3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TfFunctionRecursivityCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TfFunctionRecursivityCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TfGatherDeprecatedValidateIndicesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TfGatherDeprecatedValidateIndicesCheckTest.java
index 446bf98802..5da4ee7757 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TfGatherDeprecatedValidateIndicesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TfGatherDeprecatedValidateIndicesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TfInputShapeOnModelSubclassCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TfInputShapeOnModelSubclassCheckTest.java
index f8abd76d5a..6010336ce3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TfInputShapeOnModelSubclassCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TfInputShapeOnModelSubclassCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TfPyTorchSpecifyReductionAxisCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TfPyTorchSpecifyReductionAxisCheckTest.java
index 58dc6e5b49..3c736dd413 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TfPyTorchSpecifyReductionAxisCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TfPyTorchSpecifyReductionAxisCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TimeSleepInAsyncCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TimeSleepInAsyncCheckTest.java
index 6483691c5b..6bc1b4c494 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TimeSleepInAsyncCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TimeSleepInAsyncCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TimezoneNaiveDatetimeConstructorsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TimezoneNaiveDatetimeConstructorsCheckTest.java
index 91ae103983..fbe05591aa 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TimezoneNaiveDatetimeConstructorsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TimezoneNaiveDatetimeConstructorsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/ToDoCommentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/ToDoCommentCheckTest.java
index 7113d929b3..f7016c7d73 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/ToDoCommentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/ToDoCommentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TooManyLinesInFileCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TooManyLinesInFileCheckTest.java
index ae733d4b6b..732269b6a0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TooManyLinesInFileCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TooManyLinesInFileCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TooManyLinesInFunctionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TooManyLinesInFunctionCheckTest.java
index 045abe1dbf..67418cc2af 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TooManyLinesInFunctionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TooManyLinesInFunctionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TooManyParametersCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TooManyParametersCheckTest.java
index 1ebded15e3..efdb551cd9 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TooManyParametersCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TooManyParametersCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TooManyReturnsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TooManyReturnsCheckTest.java
index a8dc2e7041..9c5c16ebd6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TooManyReturnsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TooManyReturnsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TorchAutogradVariableShouldNotBeUsedCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TorchAutogradVariableShouldNotBeUsedCheckTest.java
index 72910130fa..1f60e05def 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TorchAutogradVariableShouldNotBeUsedCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TorchAutogradVariableShouldNotBeUsedCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TorchLoadLeadsToUntrustedCodeExecutionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TorchLoadLeadsToUntrustedCodeExecutionCheckTest.java
index 1982be419d..72dbc874b8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TorchLoadLeadsToUntrustedCodeExecutionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TorchLoadLeadsToUntrustedCodeExecutionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TorchModuleModeShouldBeSetAfterLoadingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TorchModuleModeShouldBeSetAfterLoadingCheckTest.java
index 997bd02f47..ba1675588c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TorchModuleModeShouldBeSetAfterLoadingCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TorchModuleModeShouldBeSetAfterLoadingCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TorchModuleShouldCallInitCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TorchModuleShouldCallInitCheckTest.java
index 35b9989245..768954fb37 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TorchModuleShouldCallInitCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TorchModuleShouldCallInitCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TrailingCommentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TrailingCommentCheckTest.java
index 49d543346e..a59379b293 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TrailingCommentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TrailingCommentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TrailingWhitespaceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TrailingWhitespaceCheckTest.java
index 8e88554721..a36f5d04dc 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TrailingWhitespaceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TrailingWhitespaceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TypeAliasAnnotationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TypeAliasAnnotationCheckTest.java
index c0f46cdf5f..0359bf5352 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/TypeAliasAnnotationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TypeAliasAnnotationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,15 +17,23 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 class TypeAliasAnnotationCheckTest {
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void verify_python_312_issues() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_312));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/LoggersConfigurationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TypeVarCovariantAndContravariantCheckTest.java
similarity index 58%
rename from python-checks/src/test/java/org/sonar/python/checks/hotspots/LoggersConfigurationCheckTest.java
rename to python-checks/src/test/java/org/sonar/python/checks/TypeVarCovariantAndContravariantCheckTest.java
index 40928f0721..41a92dc96d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/LoggersConfigurationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/TypeVarCovariantAndContravariantCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,14 +14,17 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-package org.sonar.python.checks.hotspots;
+package org.sonar.python.checks;
 
 import org.junit.jupiter.api.Test;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
-class LoggersConfigurationCheckTest {
+class TypeVarCovariantAndContravariantCheckTest {
+
   @Test
   void test() {
-    PythonCheckVerifier.verify("src/test/resources/checks/hotspots/loggersConfiguration.py", new LoggersConfigurationCheck());
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/typeVarCovariantAndContravariant.py",
+      new TypeVarCovariantAndContravariantCheck());
   }
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/TypeVarNamingConventionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/TypeVarNamingConventionCheckTest.java
new file mode 100644
index 0000000000..1387767c59
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/TypeVarNamingConventionCheckTest.java
@@ -0,0 +1,30 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class TypeVarNamingConventionCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/typeVarNamingConvention.py",
+      new TypeVarNamingConventionCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UndefinedNameAllPropertyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UndefinedNameAllPropertyCheckTest.java
index 231cc7a6d9..db1bbf479c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UndefinedNameAllPropertyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UndefinedNameAllPropertyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UndefinedSymbolsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UndefinedSymbolsCheckTest.java
index c513de2c1b..b039a67402 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UndefinedSymbolsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UndefinedSymbolsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnionTypeExpressionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnionTypeExpressionCheckTest.java
index 90355d3484..ebd477f68f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnionTypeExpressionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnionTypeExpressionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,6 +22,7 @@
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -30,6 +31,7 @@ class UnionTypeExpressionCheckTest {
   @AfterEach
   void reset_python_version() {
     ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
   }
 
   @Test
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryComprehensionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryComprehensionCheckTest.java
index c727b32009..b4a472ef95 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryComprehensionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryComprehensionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryLambdaMapCallCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryLambdaMapCallCheckTest.java
index 574ab17ae6..395d1a3ea1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryLambdaMapCallCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryLambdaMapCallCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryListCastCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryListCastCheckTest.java
index 296919a6d6..a196c58c68 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryListCastCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryListCastCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryListComprehensionArgumentCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryListComprehensionArgumentCheckTest.java
index 87e5ab7a8b..15b621dd15 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryListComprehensionArgumentCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryListComprehensionArgumentCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryReversedCallCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryReversedCallCheckTest.java
index 2744e1f51c..91b44a5cc7 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryReversedCallCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnnecessaryReversedCallCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnnecessarySortInsideSetCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnnecessarySortInsideSetCheckTest.java
index 31037f34e9..9b51bc1124 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnnecessarySortInsideSetCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnnecessarySortInsideSetCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnnecessarySubscriptReversalCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnnecessarySubscriptReversalCheckTest.java
index d9cccb6575..4461a53b70 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnnecessarySubscriptReversalCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnnecessarySubscriptReversalCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnprocessedTemplateStringCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnprocessedTemplateStringCheckTest.java
index 61c92886f5..73b341cd62 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnprocessedTemplateStringCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnprocessedTemplateStringCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,15 +17,23 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 class UnprocessedTemplateStringCheckTest {
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_314));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnreachableExceptCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnreachableExceptCheckTest.java
index 43b8889bbc..cb56363223 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnreachableExceptCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnreachableExceptCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateAttributesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateAttributesCheckTest.java
index c16a3e67cc..a85f26fc5e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateAttributesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateAttributesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateInnerClassesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateInnerClassesCheckTest.java
index 5c96df53ea..31b7c105a6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateInnerClassesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateInnerClassesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateMethodsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateMethodsCheckTest.java
index 02bbb7c75d..ba62a3bcfe 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateMethodsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnreadPrivateMethodsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnusedFunctionParameterCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnusedFunctionParameterCheckTest.java
index bb48f53dc6..e0abcc0029 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnusedFunctionParameterCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnusedFunctionParameterCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -57,4 +57,11 @@ void test_django() {
       ),
       new UnusedFunctionParameterCheck());
   }
+
+  @Test
+  void test_django_middleware() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/unusedFunctionParameter/django/middleware.py",
+      new UnusedFunctionParameterCheck());
+  }
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnusedImportCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnusedImportCheckTest.java
index d0a036e1c3..627d86bbe9 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnusedImportCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnusedImportCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnusedLocalVariableCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnusedLocalVariableCheckTest.java
index b6d5e0d902..296eb786f9 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnusedLocalVariableCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnusedLocalVariableCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UnusedNestedDefinitionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UnusedNestedDefinitionCheckTest.java
index 4c1da48b3b..3bf7fe4663 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UnusedNestedDefinitionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UnusedNestedDefinitionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UseOfAnyAsTypeHintCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UseOfAnyAsTypeHintCheckTest.java
index 130d50b832..076d7d924b 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UseOfAnyAsTypeHintCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UseOfAnyAsTypeHintCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UseOfEmptyReturnValueCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UseOfEmptyReturnValueCheckTest.java
index c5cd76cad7..837e21dbec 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UseOfEmptyReturnValueCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UseOfEmptyReturnValueCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UseStartsWithEndsWithCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UseStartsWithEndsWithCheckTest.java
index 6224505e62..f726f9642a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UseStartsWithEndsWithCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UseStartsWithEndsWithCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UselessParenthesisAfterKeywordCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UselessParenthesisAfterKeywordCheckTest.java
index 4ab004c4e4..0d207fec9e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UselessParenthesisAfterKeywordCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UselessParenthesisAfterKeywordCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UselessParenthesisCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UselessParenthesisCheckTest.java
index d8550060dd..bbc24f9eef 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UselessParenthesisCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UselessParenthesisCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,16 +17,24 @@
 package org.sonar.python.checks;
 
 import java.util.EnumSet;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
-import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
 import org.sonar.plugins.python.api.PythonVersionUtils;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class UselessParenthesisCheckTest {
 
+  @AfterEach
+  void reset_python_version() {
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
+  }
+
   @Test
   void test() {
     ProjectPythonVersion.setCurrentVersions(EnumSet.of(PythonVersionUtils.Version.V_314));
diff --git a/python-checks/src/test/java/org/sonar/python/checks/UselessStatementCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/UselessStatementCheckTest.java
index 7a79957e88..b1ff9a9744 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/UselessStatementCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/UselessStatementCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -47,4 +47,10 @@ void test_import() {
   void test_ignore_manifest() {
     PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/__manifest__.py", new UselessStatementCheck());
   }
+
+  @Test
+  void test_marimo() {
+    PythonCheckVerifier.verify("src/test/resources/checks/uselessStatement/uselessStatementMarimo.py", new UselessStatementCheck());
+  }
+
 }
diff --git a/python-checks/src/test/java/org/sonar/python/checks/VerifiedSslTlsCertificateCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/VerifiedSslTlsCertificateCheckTest.java
index dd15df5780..a9dae61532 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/VerifiedSslTlsCertificateCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/VerifiedSslTlsCertificateCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/WeakSSLProtocolCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/WeakSSLProtocolCheckTest.java
index aec451e687..f557f00896 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/WeakSSLProtocolCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/WeakSSLProtocolCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,12 +22,14 @@
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
+import org.sonar.python.types.TypeShed;
 
 class WeakSSLProtocolCheckTest {
 
   @AfterEach
   void reset_python_version() {
     ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
+    TypeShed.resetBuiltinSymbols();
   }
 
   @Test
diff --git a/python-checks/src/test/java/org/sonar/python/checks/WebEntryPointDecoratorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/WebEntryPointDecoratorCheckTest.java
index 889377b390..119fc23719 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/WebEntryPointDecoratorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/WebEntryPointDecoratorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/WildcardImportCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/WildcardImportCheckTest.java
index 0fffad8e03..6efd38fbeb 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/WildcardImportCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/WildcardImportCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/WrongAssignmentOperatorCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/WrongAssignmentOperatorCheckTest.java
index 299001cd9e..ab0f2270d4 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/WrongAssignmentOperatorCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/WrongAssignmentOperatorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/XMLParserXXEVulnerableCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/XMLParserXXEVulnerableCheckTest.java
index 0c56975d69..a0872daabb 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/XMLParserXXEVulnerableCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/XMLParserXXEVulnerableCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/ClearTextProtocolsCheckPartTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/ClearTextProtocolsCheckPartTest.java
index cc6188531d..bb49bcb99c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/ClearTextProtocolsCheckPartTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/ClearTextProtocolsCheckPartTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledEFSEncryptionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledEFSEncryptionCheckTest.java
index d600b3301e..d7357a393b 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledEFSEncryptionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledEFSEncryptionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledESDomainEncryptionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledESDomainEncryptionCheckTest.java
index eb79c14de1..0ad8403c40 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledESDomainEncryptionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledESDomainEncryptionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledRDSEncryptionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledRDSEncryptionCheckTest.java
index 7b30c753d3..c128619ecf 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledRDSEncryptionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledRDSEncryptionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledSNSTopicEncryptionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledSNSTopicEncryptionCheckTest.java
index a6207ec5d1..afd58a5f13 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledSNSTopicEncryptionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/DisabledSNSTopicEncryptionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/IamPolicyPublicAccessCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/IamPolicyPublicAccessCheckTest.java
index 7969569561..18a99d7325 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/IamPolicyPublicAccessCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/IamPolicyPublicAccessCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/IamPrivilegeEscalationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/IamPrivilegeEscalationCheckTest.java
index e445c0bfbb..49a402bdaf 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/IamPrivilegeEscalationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/IamPrivilegeEscalationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/NetworkCallsWithoutTimeoutsInLambdaCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/NetworkCallsWithoutTimeoutsInLambdaCheckTest.java
index 0c36895177..5829fc0bad 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/NetworkCallsWithoutTimeoutsInLambdaCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/NetworkCallsWithoutTimeoutsInLambdaCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/PrivilegePolicyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/PrivilegePolicyCheckTest.java
index e87a32994f..759d826991 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/PrivilegePolicyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/PrivilegePolicyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/PublicApiIsSecuritySensitiveCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/PublicApiIsSecuritySensitiveCheckTest.java
index 94d4f00668..dc3a97c0e4 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/PublicApiIsSecuritySensitiveCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/PublicApiIsSecuritySensitiveCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/PublicNetworkAccessToCloudResourcesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/PublicNetworkAccessToCloudResourcesCheckTest.java
index b5818cf461..8bffa84618 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/PublicNetworkAccessToCloudResourcesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/PublicNetworkAccessToCloudResourcesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/ResourceAccessPolicyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/ResourceAccessPolicyCheckTest.java
index 423130db39..d3273be752 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/ResourceAccessPolicyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/ResourceAccessPolicyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketBlockPublicAccessCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketBlockPublicAccessCheckTest.java
index 40aa76431a..8c272923e0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketBlockPublicAccessCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketBlockPublicAccessCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketGrantedAccessCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketGrantedAccessCheckTest.java
index eecefd3f9c..3e5795c8d8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketGrantedAccessCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketGrantedAccessCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketHTTPCommunicationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketHTTPCommunicationCheckTest.java
index 1654e43b92..d419dd3f7b 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketHTTPCommunicationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketHTTPCommunicationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketVersioningCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketVersioningCheckTest.java
index 9b2fc29771..0ce6db5ecf 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketVersioningCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/S3BucketVersioningCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedEbsVolumeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedEbsVolumeCheckTest.java
index 5fecda7ef5..440891422a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedEbsVolumeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedEbsVolumeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedSageMakerNotebookCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedSageMakerNotebookCheckTest.java
index ba79f9b3b3..8ec7d50814 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedSageMakerNotebookCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedSageMakerNotebookCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedSqsQueueCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedSqsQueueCheckTest.java
index 210c05cab1..f5f1c1ad68 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedSqsQueueCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnencryptedSqsQueueCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckTest.java
index d07bc596a3..2e0ebc23d4 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnrestrictedAdministrationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnrestrictedOutboundCommunicationsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnrestrictedOutboundCommunicationsCheckTest.java
index 7b66d0ce1f..af2aba6a9e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/cdk/UnrestrictedOutboundCommunicationsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/cdk/UnrestrictedOutboundCommunicationsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelFormFieldsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelFormFieldsCheckTest.java
index ac2c9d1592..084c7f0f34 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelFormFieldsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelFormFieldsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelStrMethodCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelStrMethodCheckTest.java
index e8b4d665e8..b62dc26be0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelStrMethodCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelStrMethodCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelStringFieldCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelStringFieldCheckTest.java
index 16da2800e1..9d394d8431 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelStringFieldCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/django/DjangoModelStringFieldCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/django/DjangoUtilsTest.java b/python-checks/src/test/java/org/sonar/python/checks/django/DjangoUtilsTest.java
new file mode 100644
index 0000000000..75c750c231
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/django/DjangoUtilsTest.java
@@ -0,0 +1,76 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.django;
+
+import com.sonar.sslr.api.AstNode;
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonFile;
+import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.python.TestPythonVisitorRunner;
+import org.sonar.python.parser.PythonParser;
+import org.sonar.python.tree.PythonTreeMaker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class DjangoUtilsTest {
+
+  @Test
+  void isDjangoGeneratedMigrationFile() {
+    FileInput fileInput = parse("""
+      from django.db import migrations
+      
+      class Migration(migrations.Migration):
+          pass
+      """);
+
+    assertThat(DjangoUtils.isDjangoGeneratedMigrationFile(pythonFile("accounts/migrations/0001_initial.py"), fileInput)).isTrue();
+    assertThat(DjangoUtils.isDjangoGeneratedMigrationFile(pythonFile("accounts\\migrations\\0001_initial.py"), fileInput)).isTrue();
+    assertThat(DjangoUtils.isDjangoGeneratedMigrationFile(pythonFile("accounts/migrations/manual_migration.py"), fileInput)).isFalse();
+    assertThat(DjangoUtils.isDjangoGeneratedMigrationFile(pythonFile("accounts/models/0001_initial.py"), fileInput)).isFalse();
+  }
+
+  @Test
+  void isDjangoGeneratedMigrationFile_requires_migration_class() {
+    FileInput fileInput = parse("""
+      from django.db import migrations
+      
+      class NotMigration(migrations.Migration):
+          pass
+      """);
+
+    assertThat(DjangoUtils.isDjangoGeneratedMigrationFile(pythonFile("accounts/migrations/0001_initial.py"), fileInput)).isFalse();
+  }
+
+  @Test
+  void isDjangoGeneratedMigrationFile_accepts_fully_qualified_migration_base() {
+    FileInput fileInput = parse("""
+      class Migration(django.db.migrations.Migration):
+          pass
+      """);
+
+    assertThat(DjangoUtils.isDjangoGeneratedMigrationFile(pythonFile("accounts/migrations/0001_initial.py"), fileInput)).isTrue();
+  }
+
+  private static PythonFile pythonFile(String path) {
+    return new TestPythonVisitorRunner.MockPythonFile("", path, "");
+  }
+
+  private static FileInput parse(String code) {
+    AstNode astNode = PythonParser.create().parse(code);
+    return new PythonTreeMaker().fileInput(astNode);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/ClearTextProtocolsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/ClearTextProtocolsCheckTest.java
index 448e45e3fd..d4718c3414 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/ClearTextProtocolsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/ClearTextProtocolsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/CommonValidationUtilsTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/CommonValidationUtilsTest.java
index 9cba9f256a..594518d3aa 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/CommonValidationUtilsTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/CommonValidationUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/CorsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/CorsCheckTest.java
index 16cba1e1a8..7698ee0912 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/CorsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/CorsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/CsrfDisabledCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/CsrfDisabledCheckTest.java
index 5ddd36b97b..4e24456d9d 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/CsrfDisabledCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/CsrfDisabledCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DebugModeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/DebugModeCheckTest.java
index 6e35be5a6e..96434a0547 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DebugModeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/DebugModeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeCheckTest.java
index e80f25a213..0dfc6c6b83 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeLegacyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeLegacyCheckTest.java
index 7c2adda70f..987eb57fc6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeLegacyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/DisabledHtmlAutoEscapeLegacyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/EmailSendingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/EmailSendingCheckTest.java
deleted file mode 100644
index 1fe4716f7f..0000000000
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/EmailSendingCheckTest.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the Sonar Source-Available License for more details.
- *
- * You should have received a copy of the Sonar Source-Available License
- * along with this program; if not, see https://sonarsource.com/license/ssal/
- */
-package org.sonar.python.checks.hotspots;
-
-import java.util.Collections;
-import org.junit.jupiter.api.Test;
-import org.sonar.python.checks.utils.PythonCheckVerifier;
-
-class EmailSendingCheckTest {
-  @Test
-  void test() {
-    PythonCheckVerifier.verify(Collections.singletonList("src/test/resources/checks/hotspots/emailSending.py"), new EmailSendingCheck());
-  }
-}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/ExpandingArchiveCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/ExpandingArchiveCheckTest.java
index 38b9a2f4a7..6112848954 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/ExpandingArchiveCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/ExpandingArchiveCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/FastHashingOrPlainTextCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/FastHashingOrPlainTextCheckTest.java
index ec662fb1dc..e88c2b766c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/FastHashingOrPlainTextCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/FastHashingOrPlainTextCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/GraphQLIntrospectionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/GraphQLIntrospectionCheckTest.java
index ba5db8aee0..62c5cc4b75 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/GraphQLIntrospectionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/GraphQLIntrospectionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/HardCodedCredentialsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/HardCodedCredentialsCheckTest.java
index 36fad263a5..7dbdc1c7a6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/HardCodedCredentialsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/HardCodedCredentialsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/HardCodedCredentialsEntropyCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/HardCodedCredentialsEntropyCheckTest.java
index 77fe1a7a64..84966a7025 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/HardCodedCredentialsEntropyCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/HardCodedCredentialsEntropyCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/HashingDataCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/HashingDataCheckTest.java
index 69d45c6021..92685c5556 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/HashingDataCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/HashingDataCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/HttpOnlyCookieCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/HttpOnlyCookieCheckTest.java
index fde771e368..beb70e0c7c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/HttpOnlyCookieCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/HttpOnlyCookieCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/NonStandardCryptographicAlgorithmCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/NonStandardCryptographicAlgorithmCheckTest.java
index abc99103c6..60b405624b 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/NonStandardCryptographicAlgorithmCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/NonStandardCryptographicAlgorithmCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/ProcessSignallingCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/ProcessSignallingCheckTest.java
index 9fa75c88bb..933c618f33 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/ProcessSignallingCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/ProcessSignallingCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/PseudoRandomCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/PseudoRandomCheckTest.java
index 096e77a819..a22850fd75 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/PseudoRandomCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/PseudoRandomCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/PubliclyWritableDirectoriesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/PubliclyWritableDirectoriesCheckTest.java
index 88b10a4b32..4a21921a24 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/PubliclyWritableDirectoriesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/PubliclyWritableDirectoriesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/SQLQueriesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/SQLQueriesCheckTest.java
index ae486139cf..92352555f3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/SQLQueriesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/SQLQueriesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/SecureCookieCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/SecureCookieCheckTest.java
index 7251290a6f..538971d33e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/SecureCookieCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/SecureCookieCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/StrongCryptographicKeysCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/StrongCryptographicKeysCheckTest.java
index 50e199042a..06a28b98aa 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/StrongCryptographicKeysCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/StrongCryptographicKeysCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/UnsafeHttpMethodsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/UnsafeHttpMethodsCheckTest.java
index 6d362cab32..7319d0dea0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/UnsafeHttpMethodsCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/UnsafeHttpMethodsCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -42,7 +42,8 @@ void test_django_views_and_urls_same_file() {
 
   @Test
   void test_flask() {
-    PythonCheckVerifier.verify(Arrays.asList(
+    // Flask always requires explicit method specification; any explicit choice is intentional, so no issues are raised.
+    PythonCheckVerifier.verifyNoIssue(Arrays.asList(
       "src/test/resources/checks/hotspots/unsafeHttpMethods/flask/views.py",
       "src/test/resources/checks/hotspots/unsafeHttpMethods/flask/otherDecorator.py"
     ), new UnsafeHttpMethodsCheck());
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/UnverifiedHostnameCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/UnverifiedHostnameCheckTest.java
index 6b9fb8cd00..c1a85aa7a4 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/UnverifiedHostnameCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/UnverifiedHostnameCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/hotspots/XMLSignatureValidationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/hotspots/XMLSignatureValidationCheckTest.java
index e026655363..6f23581fe1 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/hotspots/XMLSignatureValidationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/hotspots/XMLSignatureValidationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/AbstractRegexCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/AbstractRegexCheckTest.java
index fcbc441473..f4f81bc5d7 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/AbstractRegexCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/AbstractRegexCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/AnchorPrecedenceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/AnchorPrecedenceCheckTest.java
index 14a44c7d8a..66fe7f21f6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/AnchorPrecedenceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/AnchorPrecedenceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/DuplicatesInCharacterClassCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/DuplicatesInCharacterClassCheckTest.java
index 1afa4ba8e2..7fc6b4eb09 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/DuplicatesInCharacterClassCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/DuplicatesInCharacterClassCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyAlternativeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyAlternativeCheckTest.java
index 4691b3ae74..ac8d36dba9 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyAlternativeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyAlternativeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyGroupCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyGroupCheckTest.java
index 29c421d539..0a0bb65fa8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyGroupCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyGroupCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyStringRepetitionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyStringRepetitionCheckTest.java
index ca43cff22a..a7c5b09e63 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyStringRepetitionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/EmptyStringRepetitionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/GraphemeClustersInClassesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/GraphemeClustersInClassesCheckTest.java
index 9bb556b5b4..103b4d31b4 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/GraphemeClustersInClassesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/GraphemeClustersInClassesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/GroupReplacementCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/GroupReplacementCheckTest.java
index 92b6da8a3f..40ab4216c3 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/GroupReplacementCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/GroupReplacementCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/ImpossibleBackReferenceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/ImpossibleBackReferenceCheckTest.java
index a2584838bd..53d47b977c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/ImpossibleBackReferenceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/ImpossibleBackReferenceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/ImpossibleBoundariesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/ImpossibleBoundariesCheckTest.java
index 17f515fb05..6802d237d5 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/ImpossibleBoundariesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/ImpossibleBoundariesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/InvalidRegexCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/InvalidRegexCheckTest.java
index e4eaec9a45..cf1b035f46 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/InvalidRegexCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/InvalidRegexCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/MultipleWhitespaceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/MultipleWhitespaceCheckTest.java
index bc26a06ab2..f1099dfd24 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/MultipleWhitespaceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/MultipleWhitespaceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/OctalEscapeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/OctalEscapeCheckTest.java
index 8178b9fca7..b93c890221 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/OctalEscapeCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/OctalEscapeCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/PossessiveQuantifierContinuationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/PossessiveQuantifierContinuationCheckTest.java
index fad5560290..dccbb6bf12 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/PossessiveQuantifierContinuationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/PossessiveQuantifierContinuationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/RedosCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/RedosCheckTest.java
index 9dae38e7e2..e7cb9c404c 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/RedosCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/RedosCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/RedundantRegexAlternativesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/RedundantRegexAlternativesCheckTest.java
index c762be68a3..59e2517db6 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/RedundantRegexAlternativesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/RedundantRegexAlternativesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/RegexComplexityCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/RegexComplexityCheckTest.java
index d6fb4c8fa0..caa2e4c2fb 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/RegexComplexityCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/RegexComplexityCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/RegexLookaheadCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/RegexLookaheadCheckTest.java
index bd3461f9e1..39a96a7df5 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/RegexLookaheadCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/RegexLookaheadCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/ReluctantQuantifierCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/ReluctantQuantifierCheckTest.java
index 3ce914e210..5007f2797a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/ReluctantQuantifierCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/ReluctantQuantifierCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/ReluctantQuantifierWithEmptyContinuationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/ReluctantQuantifierWithEmptyContinuationCheckTest.java
index a97a6bb420..10bec7d3e7 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/ReluctantQuantifierWithEmptyContinuationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/ReluctantQuantifierWithEmptyContinuationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/SingleCharCharacterClassCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/SingleCharCharacterClassCheckTest.java
index 9b501d2ecf..eb3140b226 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/SingleCharCharacterClassCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/SingleCharCharacterClassCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/SingleCharacterAlternationCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/SingleCharacterAlternationCheckTest.java
index f239309b92..7c3db05aad 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/SingleCharacterAlternationCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/SingleCharacterAlternationCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/StringReplaceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/StringReplaceCheckTest.java
index 7118caddae..e9c3c11423 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/StringReplaceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/StringReplaceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/SuperLinearRegexCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/SuperLinearRegexCheckTest.java
new file mode 100644
index 0000000000..ab4d77ca79
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/SuperLinearRegexCheckTest.java
@@ -0,0 +1,28 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.regex;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class SuperLinearRegexCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/regex/superLinearRegexCheck.py", new SuperLinearRegexCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/SuperfluousCurlyBraceCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/SuperfluousCurlyBraceCheckTest.java
index 6156eed3a8..3cacfcb42e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/SuperfluousCurlyBraceCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/SuperfluousCurlyBraceCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/UnquantifiedNonCapturingGroupCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/UnquantifiedNonCapturingGroupCheckTest.java
index dd52d89af8..023bb1cce0 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/UnquantifiedNonCapturingGroupCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/UnquantifiedNonCapturingGroupCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/UnusedGroupNamesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/UnusedGroupNamesCheckTest.java
index 0e5e032c6d..ef0966629f 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/UnusedGroupNamesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/UnusedGroupNamesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/regex/VerboseRegexCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/regex/VerboseRegexCheckTest.java
index 203387d03c..a5128a6f25 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/regex/VerboseRegexCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/regex/VerboseRegexCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/AssertAfterRaiseCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertAfterRaiseCheckTest.java
index c866c84351..f475723fdf 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/tests/AssertAfterRaiseCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertAfterRaiseCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/AssertOnDissimilarTypesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertOnDissimilarTypesCheckTest.java
index f771659d67..e342cf72da 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/tests/AssertOnDissimilarTypesCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertOnDissimilarTypesCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/AssertOnTupleLiteralCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertOnTupleLiteralCheckTest.java
index b460e877e2..c91c7c17e8 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/tests/AssertOnTupleLiteralCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertOnTupleLiteralCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/AssertionArgumentOrderCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertionArgumentOrderCheckTest.java
new file mode 100644
index 0000000000..9882b1e4b7
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertionArgumentOrderCheckTest.java
@@ -0,0 +1,366 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import java.lang.reflect.Method;
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+
+class AssertionArgumentOrderCheckTest {
+  private static final AssertionArgumentOrderCheck CHECK = new AssertionArgumentOrderCheck();
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/test_assertionArgumentOrder.py", CHECK);
+  }
+
+  @Test
+  void test_pytest() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/test_assertionArgumentOrderPytest.py", CHECK);
+  }
+
+  @Test
+  void test_assertpy_consistent_expected_first() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/test_assertionArgumentOrderAssertpy.py", CHECK);
+  }
+
+  @Test
+  void test_consistent_actual_first() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/test_assertionArgumentOrderExpectedLeft.py", CHECK);
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(CHECK.scope()).isEqualTo(PythonCheck.CheckScope.TESTS);
+  }
+
+  @Test
+  void unify_quick_fixes_unittest() {
+    String before = """
+      import unittest
+
+      def value():
+          return 41 + 1
+
+      class MyTest(unittest.TestCase):
+          def test_order(self):
+              self.assertEqual(first=42, second=value())
+              self.assertEqual(value(), 42)
+      """;
+    String putExpectedSecond = """
+      import unittest
+
+      def value():
+          return 41 + 1
+
+      class MyTest(unittest.TestCase):
+          def test_order(self):
+              self.assertEqual(first=value(), second=42)
+              self.assertEqual(value(), 42)
+      """;
+    String putActualSecond = """
+      import unittest
+
+      def value():
+          return 41 + 1
+
+      class MyTest(unittest.TestCase):
+          def test_order(self):
+              self.assertEqual(first=42, second=value())
+              self.assertEqual(42, value())
+      """;
+    PythonQuickFixVerifier.verifySemantic(CHECK, "unittest_case.py", before, putExpectedSecond, putActualSecond);
+    PythonQuickFixVerifier.verifySemanticQuickFixMessages(CHECK, "unittest_case.py", before,
+      "Put all expected values second",
+      "Put all actual values second");
+  }
+
+  @Test
+  void unify_quick_fixes_pytest() {
+    String before = """
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert 42 == value()
+          assert value() == 42
+      """;
+    String putExpectedSecond = """
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert value() == 42
+          assert value() == 42
+      """;
+    String putActualSecond = """
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert 42 == value()
+          assert 42 == value()
+      """;
+    PythonQuickFixVerifier.verifySemantic(CHECK, "test_pytest_case.py", before, putExpectedSecond, putActualSecond);
+    PythonQuickFixVerifier.verifySemanticQuickFixMessages(CHECK, "test_pytest_case.py", before,
+      "Put all expected values second",
+      "Put all actual values second");
+  }
+
+  @Test
+  void unify_quick_fixes_pytest_approx() {
+    String before = """
+      import pytest
+
+      def value():
+          return 3.14
+
+      def test_order():
+          assert 42 == pytest.approx(value(), abs=0.1)
+          assert value() == pytest.approx(42, abs=0.1)
+      """;
+    String putExpectedSecond = """
+      import pytest
+
+      def value():
+          return 3.14
+
+      def test_order():
+          assert value() == pytest.approx(42, abs=0.1)
+          assert value() == pytest.approx(42, abs=0.1)
+      """;
+    String putActualSecond = """
+      import pytest
+
+      def value():
+          return 3.14
+
+      def test_order():
+          assert 42 == pytest.approx(value(), abs=0.1)
+          assert pytest.approx(42, abs=0.1) == value()
+      """;
+    PythonQuickFixVerifier.verifySemantic(CHECK, "test_pytest_approx_case.py", before, putExpectedSecond, putActualSecond);
+    PythonQuickFixVerifier.verifySemanticQuickFixMessages(CHECK, "test_pytest_approx_case.py", before,
+      "Put all expected values second",
+      "Put all actual values second");
+  }
+
+  @Test
+  void unify_quick_fixes_assertpy() {
+    String before = """
+      from assertpy import assert_that
+
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert_that(42).described_as("count").is_equal_to(value())
+          assert_that(value()).described_as("count").is_equal_to(42)
+      """;
+    String putExpectedSecond = """
+      from assertpy import assert_that
+
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert_that(value()).described_as("count").is_equal_to(42)
+          assert_that(value()).described_as("count").is_equal_to(42)
+      """;
+    String putActualSecond = """
+      from assertpy import assert_that
+
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert_that(42).described_as("count").is_equal_to(value())
+          assert_that(42).described_as("count").is_equal_to(value())
+      """;
+    PythonQuickFixVerifier.verifySemantic(CHECK, "test_assertpy_case.py", before, putExpectedSecond, putActualSecond);
+    PythonQuickFixVerifier.verifySemanticQuickFixMessages(CHECK, "test_assertpy_case.py", before,
+      "Put all expected values second",
+      "Put all actual values second");
+  }
+
+  @Test
+  void unify_quick_fix_for_multiline_operand() {
+    String before = """
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert 42 == (
+              value()
+          )
+          assert value() == 42
+      """;
+    String putExpectedSecond = """
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert (
+              value()
+          ) == 42
+          assert value() == 42
+      """;
+    String putActualSecond = """
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert 42 == (
+              value()
+          )
+          assert 42 == value()
+      """;
+    PythonQuickFixVerifier.verifySemantic(CHECK, "test_pytest_multiline_case.py", before, putExpectedSecond, putActualSecond);
+  }
+
+  @Test
+  void unify_quick_fix_with_windows_line_endings() {
+    String before = """
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert 42 == value()
+          assert value() == 42
+      """.replace("\n", "\r\n");
+    String putExpectedSecond = """
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert value() == 42
+          assert value() == 42
+      """.replace("\n", "\r\n");
+    String putActualSecond = """
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert 42 == value()
+          assert 42 == value()
+      """.replace("\n", "\r\n");
+    PythonQuickFixVerifier.verifySemantic(CHECK, "test_pytest_windows_case.py", before, putExpectedSecond, putActualSecond);
+  }
+
+  @Test
+  void unify_quick_fix_pytest_approx_with_expected_keyword() {
+    String before = """
+      import pytest
+
+      def value():
+          return 3.14
+
+      def test_order():
+          assert 42 == pytest.approx(expected=value(), abs=0.1)
+          assert value() == pytest.approx(expected=42, abs=0.1)
+      """;
+    String putExpectedSecond = """
+      import pytest
+
+      def value():
+          return 3.14
+
+      def test_order():
+          assert value() == pytest.approx(expected=42, abs=0.1)
+          assert value() == pytest.approx(expected=42, abs=0.1)
+      """;
+    String putActualSecond = """
+      import pytest
+
+      def value():
+          return 3.14
+
+      def test_order():
+          assert 42 == pytest.approx(expected=value(), abs=0.1)
+          assert pytest.approx(expected=42, abs=0.1) == value()
+      """;
+    PythonQuickFixVerifier.verifySemantic(CHECK, "test_pytest_keyword_approx_case.py", before, putExpectedSecond, putActualSecond);
+  }
+
+  @Test
+  void unify_quick_fix_suppressed_when_any_assertion_cannot_be_edited() {
+    String before = """
+      import pytest
+
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert 42 == value()
+          assert 42 == pytest.approx(other=value())
+          assert value() == 42
+      """;
+    String putActualSecond = """
+      import pytest
+
+      def value():
+          return 41 + 1
+
+      def test_order():
+          assert 42 == value()
+          assert 42 == pytest.approx(other=value())
+          assert 42 == value()
+      """;
+    // expected-first group includes an approx call without a swappable expected arg, so that unify QF is suppressed
+    PythonQuickFixVerifier.verifySemantic(CHECK, "test_pytest_partial_qf_case.py", before, putActualSecond);
+    PythonQuickFixVerifier.verifySemanticQuickFixMessages(CHECK, "test_pytest_partial_qf_case.py", before,
+      "Put all actual values second");
+  }
+
+  @Test
+  void leave_file_is_noop_before_initialize() {
+    AssertionArgumentOrderCheck check = new AssertionArgumentOrderCheck();
+    assertThatCode(check::leaveFile).doesNotThrowAnyException();
+  }
+
+  @Test
+  void convert_position_to_index_handles_crlf_and_invalid_positions() throws Exception {
+    Method method = AssertionArgumentOrderCheck.class.getDeclaredMethod("convertPositionToIndex", String.class, int.class, int.class);
+    method.setAccessible(true);
+
+    String code = "a = 1\r\nb = 2\r\n";
+    assertThat(method.invoke(null, code, 2, 0)).isEqualTo(7);
+    assertThat(method.invoke(null, code, 2, 5)).isEqualTo(12);
+    assertThat(method.invoke(null, code, 99, 0)).isEqualTo(-1);
+    assertThat(method.invoke(null, code, 1, -1)).isEqualTo(-1);
+    assertThat(method.invoke(null, code, 1, 50)).isEqualTo(-1);
+    assertThat(method.invoke(null, code, 4, 0)).isEqualTo(-1);
+    assertThat(method.invoke(null, code, 2, -1)).isEqualTo(-1);
+    assertThat(method.invoke(null, code, 2, 6)).isEqualTo(-1);
+  }
+
+  @Test
+  void next_index_handles_all_line_break_variants() throws Exception {
+    Method method = AssertionArgumentOrderCheck.class.getDeclaredMethod("nextIndex", String.class, int.class);
+    method.setAccessible(true);
+
+    assertThat(method.invoke(null, "a", 0)).isEqualTo(1);
+    assertThat(method.invoke(null, "\n", 0)).isEqualTo(1);
+    assertThat(method.invoke(null, "\r", 0)).isEqualTo(1);
+    assertThat(method.invoke(null, "\r\n", 0)).isEqualTo(2);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/AssertionInTryCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertionInTryCheckTest.java
new file mode 100644
index 0000000000..30ca3aed2f
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/AssertionInTryCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class AssertionInTryCheckTest {
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new AssertionInTryCheck().scope());
+  }
+
+  @Test
+  void sample() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/assertionInTry.py", new AssertionInTryCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/CompositeAssertionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/CompositeAssertionCheckTest.java
new file mode 100644
index 0000000000..d8eae51152
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/CompositeAssertionCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class CompositeAssertionCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/test_compositeAssertion.py", new CompositeAssertionCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new CompositeAssertionCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/DedicatedAssertionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/DedicatedAssertionCheckTest.java
index db84ca19a1..a1a368cc18 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/tests/DedicatedAssertionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/DedicatedAssertionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/DedicatedExceptionAssertionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/DedicatedExceptionAssertionCheckTest.java
new file mode 100644
index 0000000000..127afb023f
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/DedicatedExceptionAssertionCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class DedicatedExceptionAssertionCheckTest {
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new DedicatedExceptionAssertionCheck().scope());
+  }
+
+  @Test
+  void sample() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/dedicatedExceptionAssertion.py", new DedicatedExceptionAssertionCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/DeprecatedYieldFixtureCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/DeprecatedYieldFixtureCheckTest.java
new file mode 100644
index 0000000000..9c30665127
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/DeprecatedYieldFixtureCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class DeprecatedYieldFixtureCheckTest {
+
+  @Test
+  void scope() {
+    assertThat(new DeprecatedYieldFixtureCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/deprecatedYieldFixture.py", new DeprecatedYieldFixtureCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/DuplicateParametrizeCasesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/DuplicateParametrizeCasesCheckTest.java
new file mode 100644
index 0000000000..d96017d0cc
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/DuplicateParametrizeCasesCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class DuplicateParametrizeCasesCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/duplicateParametrizeCases.py", new DuplicateParametrizeCasesCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new DuplicateParametrizeCasesCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/EmptyParametrizeValuesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/EmptyParametrizeValuesCheckTest.java
new file mode 100644
index 0000000000..67b1da564b
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/EmptyParametrizeValuesCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class EmptyParametrizeValuesCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/emptyParametrizeValues.py", new EmptyParametrizeValuesCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new EmptyParametrizeValuesCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/FixtureParamDependenciesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/FixtureParamDependenciesCheckTest.java
new file mode 100644
index 0000000000..601877e738
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/FixtureParamDependenciesCheckTest.java
@@ -0,0 +1,51 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class FixtureParamDependenciesCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/fixtureParamDependencies_test.py", new FixtureParamDependenciesCheck());
+  }
+
+  @Test
+  void test_conftest() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/conftest.py", new FixtureParamDependenciesCheck());
+  }
+
+  @Test
+  void test_non_pytest_file() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/fixtureParamDependenciesNonPytestFile.py", new FixtureParamDependenciesCheck());
+  }
+
+  @Test
+  void test_pytest_hooks_and_imported_fixture() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/fixtureParamDependenciesPytestHook_test.py", new FixtureParamDependenciesCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new FixtureParamDependenciesCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/GroupSimilarTestsParameterizedCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/GroupSimilarTestsParameterizedCheckTest.java
new file mode 100644
index 0000000000..926587ef2b
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/GroupSimilarTestsParameterizedCheckTest.java
@@ -0,0 +1,294 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.net.URI;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.plugins.python.api.SubscriptionContext;
+import org.sonar.plugins.python.api.symbols.ClassSymbol;
+import org.sonar.plugins.python.api.symbols.Symbol;
+import org.sonar.plugins.python.api.tree.ClassDef;
+import org.sonar.plugins.python.api.tree.FunctionDef;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.RaiseStatement;
+import org.sonar.plugins.python.api.tree.Token;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class GroupSimilarTestsParameterizedCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/test_groupSimilarTestsParameterized.py", new GroupSimilarTestsParameterizedCheck());
+  }
+
+  @Test
+  void testNonTestFileName() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/groupSimilarTestsParameterized.py", new GroupSimilarTestsParameterizedCheck());
+  }
+
+  @Test
+  void testUnderscoreTestSuffixFileName() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/groupSimilarTestsParameterized_test.py", new GroupSimilarTestsParameterizedCheck());
+  }
+
+  @Test
+  void testEmptyFile() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/empty_groupSimilarTestsParameterized.py", new GroupSimilarTestsParameterizedCheck());
+  }
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new GroupSimilarTestsParameterizedCheck().scope());
+  }
+
+  @Test
+  void same_test_kind_can_differ_between_pytest_and_unittest() throws Exception {
+    FunctionDef unittestFunction = functionDef(unittestClassDef());
+    FunctionDef pytestFunction = functionDef(null);
+
+    assertFalse((boolean) invokePrivateStaticMethod("sameTestKind", new Class[] {FunctionDef.class, FunctionDef.class}, unittestFunction, pytestFunction));
+  }
+
+  @Test
+  void similar_tests_reject_mixed_test_kinds() throws Exception {
+    FunctionDef unittestFunction = functionDef("test_variant_1", unittestClassDef());
+    FunctionDef pytestFunction = functionDef("test_variant_1", null);
+
+    assertFalse((boolean) invokePrivateStaticMethod("areSimilarTests", new Class[] {FunctionDef.class, FunctionDef.class}, unittestFunction, pytestFunction));
+  }
+
+  @Test
+  void not_implemented_error_raise_rejects_raise_without_expression() throws Exception {
+    RaiseStatement bareRaise = proxy(RaiseStatement.class, Map.of("expressions", List.of()));
+
+    assertFalse((boolean) invokePrivateStaticMethod("isNotImplementedErrorRaise",
+      new Class[] {org.sonar.plugins.python.api.tree.Statement.class, SubscriptionContext.class},
+      bareRaise, dummySubscriptionContext()));
+  }
+
+  @Test
+  void difference_counter_handles_defensive_null_paths() throws Exception {
+    Object counter = newDifferenceCounter();
+    Method areSimilar = differenceCounterMethod("areSimilar", Tree.class, Tree.class);
+
+    assertTrue((boolean) areSimilar.invoke(counter, null, null));
+
+    Tree tree = leaf(Tree.Kind.NAME, "value", null);
+    assertFalse((boolean) areSimilar.invoke(counter, tree, null));
+  }
+
+  @Test
+  void difference_counter_handles_leafs_without_tokens_or_parents() throws Exception {
+    Method areSimilar = differenceCounterMethod("areSimilar", Tree.class, Tree.class);
+    Method compareLeaves = differenceCounterMethod("compareLeaves", Tree.class, Tree.class);
+
+    Tree leafWithoutToken1 = leaf(Tree.Kind.PASS_STMT, null, null);
+    Tree leafWithoutToken2 = leaf(Tree.Kind.PASS_STMT, null, null);
+    assertTrue((boolean) areSimilar.invoke(newDifferenceCounter(), leafWithoutToken1, leafWithoutToken2));
+
+    Tree nonParameterizableLeaf1 = leaf(Tree.Kind.PASS_STMT, "left", null);
+    Tree nonParameterizableLeaf2 = leaf(Tree.Kind.PASS_STMT, "right", null);
+    assertFalse((boolean) areSimilar.invoke(newDifferenceCounter(), nonParameterizableLeaf1, nonParameterizableLeaf2));
+
+    Tree parameterizableLeaf1 = leaf(Tree.Kind.NUMERIC_LITERAL, "1", null);
+    Tree parameterizableLeaf2 = leaf(Tree.Kind.NUMERIC_LITERAL, "2", null);
+    assertTrue((boolean) areSimilar.invoke(newDifferenceCounter(), parameterizableLeaf1, parameterizableLeaf2));
+
+    Tree leftNullTokenLeaf = leaf(Tree.Kind.PASS_STMT, null, null);
+    Tree rightTokenLeaf = leaf(Tree.Kind.PASS_STMT, "right", null);
+    assertFalse((boolean) compareLeaves.invoke(newDifferenceCounter(), leftNullTokenLeaf, rightTokenLeaf));
+
+    Tree rightNonParameterizableLeaf = leaf(Tree.Kind.PASS_STMT, "right", null);
+    assertFalse((boolean) compareLeaves.invoke(newDifferenceCounter(), parameterizableLeaf1, rightNonParameterizableLeaf));
+  }
+
+  @Test
+  void difference_counter_handles_left_null_and_nested_trees() throws Exception {
+    Method areSimilar = differenceCounterMethod("areSimilar", Tree.class, Tree.class);
+
+    Tree tree = leaf(Tree.Kind.PASS_STMT, "value", null);
+    assertFalse((boolean) areSimilar.invoke(newDifferenceCounter(), null, tree));
+
+    Tree nestedLeft = tree(Tree.Kind.TUPLE, List.of(leaf(Tree.Kind.NUMERIC_LITERAL, "1", null)));
+    Tree nestedRight = tree(Tree.Kind.TUPLE, List.of(leaf(Tree.Kind.NUMERIC_LITERAL, "1", null)));
+    assertTrue((boolean) areSimilar.invoke(newDifferenceCounter(), nestedLeft, nestedRight));
+  }
+
+  private static Object newDifferenceCounter() throws Exception {
+    Constructor constructor = Class.forName("org.sonar.python.checks.tests.GroupSimilarTestsParameterizedCheck$DifferenceCounter").getDeclaredConstructor();
+    constructor.setAccessible(true);
+    return constructor.newInstance();
+  }
+
+  private static Method differenceCounterMethod(String name, Class... parameterTypes) throws Exception {
+    Method method = Class.forName("org.sonar.python.checks.tests.GroupSimilarTestsParameterizedCheck$DifferenceCounter")
+      .getDeclaredMethod(name, parameterTypes);
+    method.setAccessible(true);
+    return method;
+  }
+
+  private static Object invokePrivateStaticMethod(String name, Class[] parameterTypes, Object... arguments) throws Exception {
+    Method method = GroupSimilarTestsParameterizedCheck.class.getDeclaredMethod(name, parameterTypes);
+    method.setAccessible(true);
+    return method.invoke(null, arguments);
+  }
+
+  private static ClassDef unittestClassDef() {
+    Symbol parentClass = proxy(Symbol.class, Map.of(
+      "fullyQualifiedName", "unittest.case.TestCase"));
+
+    ClassSymbol classSymbol = proxy(ClassSymbol.class, Map.of(
+      "kind", Symbol.Kind.CLASS,
+      "superClasses", List.of(parentClass)));
+
+    Map classNameConfig = new HashMap<>();
+    classNameConfig.put("symbol", classSymbol);
+    classNameConfig.put("kind", Tree.Kind.NAME);
+    classNameConfig.put("children", List.of());
+    classNameConfig.put("parent", null);
+    classNameConfig.put("firstToken", null);
+    Name className = proxy(Name.class, classNameConfig);
+
+    Map classDefConfig = new HashMap<>();
+    classDefConfig.put("kind", Tree.Kind.CLASSDEF);
+    classDefConfig.put("name", className);
+    classDefConfig.put("parent", null);
+    classDefConfig.put("children", List.of());
+    classDefConfig.put("firstToken", null);
+    return proxy(ClassDef.class, classDefConfig);
+  }
+
+  private static FunctionDef functionDef(Tree parent) {
+    return functionDef("test_variant", parent);
+  }
+
+  private static FunctionDef functionDef(String name, Tree parent) {
+    Map nameConfig = new HashMap<>();
+    nameConfig.put("kind", Tree.Kind.NAME);
+    nameConfig.put("name", name);
+    nameConfig.put("children", List.of());
+    nameConfig.put("parent", null);
+    nameConfig.put("firstToken", null);
+    Name functionName = proxy(Name.class, nameConfig);
+
+    Map functionConfig = new HashMap<>();
+    functionConfig.put("kind", Tree.Kind.FUNCDEF);
+    functionConfig.put("name", functionName);
+    functionConfig.put("parent", parent);
+    functionConfig.put("children", List.of());
+    functionConfig.put("firstToken", null);
+    functionConfig.put("parameters", null);
+    functionConfig.put("body", null);
+    return proxy(FunctionDef.class, functionConfig);
+  }
+
+  private static Tree leaf(Tree.Kind kind, String tokenValue, Tree parent) {
+    Token token = tokenValue == null ? null : proxy(Token.class, Map.of("value", tokenValue));
+    Map treeConfig = new HashMap<>();
+    treeConfig.put("kind", kind);
+    treeConfig.put("children", List.of());
+    treeConfig.put("parent", parent);
+    treeConfig.put("firstToken", token);
+    return proxy(Tree.class, treeConfig);
+  }
+
+  private static Tree tree(Tree.Kind kind, List children) {
+    Map treeConfig = new HashMap<>();
+    treeConfig.put("kind", kind);
+    treeConfig.put("children", children);
+    treeConfig.put("parent", null);
+    treeConfig.put("firstToken", null);
+    return proxy(Tree.class, treeConfig);
+  }
+
+  private static SubscriptionContext dummySubscriptionContext() {
+    return proxy(SubscriptionContext.class, Map.of(
+      "pythonFile", new org.sonar.plugins.python.api.PythonFile() {
+        @Override
+        public String content() {
+          return "";
+        }
+
+        @Override
+        public String fileName() {
+          return "test_groupSimilarTestsParameterized.py";
+        }
+
+        @Override
+        public URI uri() {
+          return URI.create("file:///test_groupSimilarTestsParameterized.py");
+        }
+
+        @Override
+        public String key() {
+          return "test_groupSimilarTestsParameterized.py";
+        }
+      }));
+  }
+
+  @SuppressWarnings("unchecked")
+  private static  T proxy(Class type, Map values) {
+    Map config = new HashMap<>(values);
+    return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class[] {type}, (proxy, method, args) -> switch (method.getName()) {
+      case "getKind" -> config.get("kind");
+      case "children" -> config.getOrDefault("children", List.of());
+      case "parent" -> config.get("parent");
+      case "firstToken" -> config.get("firstToken");
+      case "name" -> config.get("name");
+      case "parameters" -> config.get("parameters");
+      case "body" -> config.get("body");
+      case "symbol" -> config.get("symbol");
+      case "kind" -> config.get("kind");
+      case "superClasses" -> config.getOrDefault("superClasses", List.of());
+      case "fullyQualifiedName" -> config.get("fullyQualifiedName");
+      case "expressions" -> config.getOrDefault("expressions", List.of());
+      case "pythonFile" -> config.get("pythonFile");
+      case "value" -> config.get("value");
+      case "is" -> Arrays.stream((Tree.Kind[]) args[0]).anyMatch(config.get("kind")::equals);
+      case "hashCode" -> System.identityHashCode(proxy);
+      case "equals" -> proxy == args[0];
+      case "toString" -> type.getSimpleName() + config;
+      default -> defaultValue(method.getReturnType());
+    });
+  }
+
+  private static Object defaultValue(Class returnType) {
+    if (!returnType.isPrimitive()) {
+      return null;
+    }
+    if (boolean.class.equals(returnType)) {
+      return false;
+    }
+    if (char.class.equals(returnType)) {
+      return '\0';
+    }
+    return 0;
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/IdenticalAssertionArgumentsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/IdenticalAssertionArgumentsCheckTest.java
new file mode 100644
index 0000000000..1c09c37dbd
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/IdenticalAssertionArgumentsCheckTest.java
@@ -0,0 +1,37 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class IdenticalAssertionArgumentsCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/test_identicalAssertionArguments.py", new IdenticalAssertionArgumentsCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new IdenticalAssertionArgumentsCheck().scope()).isEqualTo(PythonCheck.CheckScope.TESTS);
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/ImplicitlySkippedTestCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/ImplicitlySkippedTestCheckTest.java
index 7dae43a2df..acf2827549 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/tests/ImplicitlySkippedTestCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/ImplicitlySkippedTestCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/IntentionalTestFailureMessageCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/IntentionalTestFailureMessageCheckTest.java
new file mode 100644
index 0000000000..0704109420
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/IntentionalTestFailureMessageCheckTest.java
@@ -0,0 +1,65 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class IntentionalTestFailureMessageCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/intentionalTestFailureMessage.py", new IntentionalTestFailureMessageCheck());
+  }
+
+  @Test
+  void test_no_pytest_import() {
+    PythonCheckVerifier.verifyNoIssue(
+      "src/test/resources/checks/tests/intentionalTestFailureMessageNoPytest.py",
+      new IntentionalTestFailureMessageCheck());
+  }
+
+  @Test
+  void test_from_pytest_import() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/tests/intentionalTestFailureMessageFromImport.py",
+      new IntentionalTestFailureMessageCheck());
+  }
+
+  @Test
+  void test_multiple_pytest_imports() {
+    PythonCheckVerifier.verify(
+      "src/test/resources/checks/tests/intentionalTestFailureMessageMultipleImports.py",
+      new IntentionalTestFailureMessageCheck());
+  }
+
+  @Test
+  void test_relative_import_does_not_enable_assert() {
+    PythonCheckVerifier.verifyNoIssue(
+      "src/test/resources/checks/tests/intentionalTestFailureMessageRelativeImport.py",
+      new IntentionalTestFailureMessageCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new IntentionalTestFailureMessageCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/MisspelledMockAssertionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/MisspelledMockAssertionCheckTest.java
new file mode 100644
index 0000000000..16d084f73c
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/MisspelledMockAssertionCheckTest.java
@@ -0,0 +1,53 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class MisspelledMockAssertionCheckTest {
+
+  private static final MisspelledMockAssertionCheck CHECK = new MisspelledMockAssertionCheck();
+  private static final String FILE_NAME = "src/test/resources/checks/tests/misspelledMockAssertion.py";
+
+  @Test
+  void scope() {
+    assertThat(CHECK.scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify(FILE_NAME, CHECK);
+  }
+
+  @Test
+  void quick_fix() {
+    PythonQuickFixVerifier.verifySemantic(CHECK, FILE_NAME, """
+      from unittest.mock import Mock
+      m = Mock()
+      m.assert_called_wit(1)
+      """, """
+      from unittest.mock import Mock
+      m = Mock()
+      m.assert_called_with(1)
+      """);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/MockPatchLambdaReturnValueCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/MockPatchLambdaReturnValueCheckTest.java
new file mode 100644
index 0000000000..8e0c27cbc6
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/MockPatchLambdaReturnValueCheckTest.java
@@ -0,0 +1,155 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class MockPatchLambdaReturnValueCheckTest {
+
+  @Test
+  void scope() {
+    assertThat(new MockPatchLambdaReturnValueCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/mockPatchLambdaReturnValue.py", new MockPatchLambdaReturnValueCheck());
+  }
+
+  @Test
+  void quickFixOnPositionalLambda() {
+    PythonQuickFixVerifier.verify(new MockPatchLambdaReturnValueCheck(),
+      """
+        from unittest.mock import patch
+        patch("app.api.fetch", lambda: {"ok": True})
+        """,
+      """
+        from unittest.mock import patch
+        patch("app.api.fetch", return_value={"ok": True})
+        """);
+  }
+
+  @Test
+  void quickFixOnKeywordLambda() {
+    PythonQuickFixVerifier.verify(new MockPatchLambdaReturnValueCheck(),
+      """
+        from unittest.mock import patch
+        patch("app.api.fetch", new=lambda *args: 42)
+        """,
+      """
+        from unittest.mock import patch
+        patch("app.api.fetch", return_value=42)
+        """);
+  }
+
+  @Test
+  void quickFixOnPatchObject() {
+    PythonQuickFixVerifier.verify(new MockPatchLambdaReturnValueCheck(),
+      """
+        from unittest.mock import patch
+        patch.object(Target, "attribute", lambda x, y: 7)
+        """,
+      """
+        from unittest.mock import patch
+        patch.object(Target, "attribute", return_value=7)
+        """);
+  }
+
+  @Test
+  void quickFixOnMockerPatch() {
+    PythonQuickFixVerifier.verify(new MockPatchLambdaReturnValueCheck(),
+      """
+        def test_something(mocker):
+            mocker.patch("module.target", (lambda: 7))
+        """,
+      """
+        def test_something(mocker):
+            mocker.patch("module.target", return_value=7)
+        """);
+  }
+
+  @Test
+  void quickFixMessage() {
+    PythonQuickFixVerifier.verifyQuickFixMessages(new MockPatchLambdaReturnValueCheck(),
+      """
+        from unittest.mock import patch
+        patch("app.api.fetch", lambda: 42)
+        """,
+      "Replace this lambda with a \"return_value\" argument");
+  }
+
+  @Test
+  void noQuickFixWhenPositionalArgumentsFollow() {
+    PythonQuickFixVerifier.verifyNoQuickFixes(new MockPatchLambdaReturnValueCheck(),
+      """
+        from unittest.mock import patch
+        patch("app.api.fetch", lambda: 42, True)
+        """);
+  }
+
+  @Test
+  void quickFixWithKeywordArgumentAfterLambda() {
+    PythonQuickFixVerifier.verify(new MockPatchLambdaReturnValueCheck(),
+      """
+        from unittest.mock import patch
+        patch("app.api.fetch", lambda: 42, autospec=True)
+        """,
+      """
+        from unittest.mock import patch
+        patch("app.api.fetch", return_value=42, autospec=True)
+        """);
+  }
+
+  @Test
+  void noQuickFixOnDecorator() {
+    PythonQuickFixVerifier.verifyNoQuickFixes(new MockPatchLambdaReturnValueCheck(),
+      """
+        from unittest.mock import patch
+        @patch("app.api.fetch", lambda: 42)
+        def test_something():
+            ...
+        """);
+  }
+
+  @Test
+  void noQuickFixWhenLambdaBodyContainsCall() {
+    PythonQuickFixVerifier.verifyNoQuickFixes(new MockPatchLambdaReturnValueCheck(),
+      """
+        from unittest.mock import patch
+        def helper():
+            ...
+        with patch("app.api.fetch", lambda: helper()):
+            ...
+        """);
+  }
+
+  @Test
+  void noQuickFixOnMultilineLambdaBody() {
+    PythonQuickFixVerifier.verifyNoQuickFixes(new MockPatchLambdaReturnValueCheck(),
+      """
+        from unittest.mock import patch
+        patch("app.api.fetch", lambda: {
+            "ok": True,
+        })
+        """);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/MocksShouldUseAutospecCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/MocksShouldUseAutospecCheckTest.java
new file mode 100644
index 0000000000..6deab2dad1
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/MocksShouldUseAutospecCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class MocksShouldUseAutospecCheckTest {
+
+  @Test
+  void scope() {
+    assertThat(new MocksShouldUseAutospecCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/mocksShouldUseAutospec.py", new MocksShouldUseAutospecCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/NotDiscoverableTestMethodCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/NotDiscoverableTestMethodCheckTest.java
index 664699c38e..9f5aa795ba 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/tests/NotDiscoverableTestMethodCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/NotDiscoverableTestMethodCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestAutouseParametrizedFixtureCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestAutouseParametrizedFixtureCheckTest.java
new file mode 100644
index 0000000000..fdc78ea977
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestAutouseParametrizedFixtureCheckTest.java
@@ -0,0 +1,37 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestAutouseParametrizedFixtureCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestAutouseParametrizedFixture.py", new PytestAutouseParametrizedFixtureCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new PytestAutouseParametrizedFixtureCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestDecoratorParenthesesCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestDecoratorParenthesesCheckTest.java
new file mode 100644
index 0000000000..6e01aaa8db
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestDecoratorParenthesesCheckTest.java
@@ -0,0 +1,178 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestDecoratorParenthesesCheckTest {
+
+  private static final String FILE_NAME = "test_pytest_decorator_parentheses.py";
+  private static final PytestDecoratorParenthesesCheck CHECK = new PytestDecoratorParenthesesCheck();
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestDecoratorParentheses.py", CHECK);
+  }
+
+  @Test
+  void test_require_parentheses() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestDecoratorParenthesesRequired.py", checkRequiringParentheses());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(CHECK.scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void quick_fix_removes_empty_parentheses() {
+    String before = """
+      import pytest
+
+      @pytest.fixture()
+      def sample():
+          return 1
+      """;
+    String after = """
+      import pytest
+
+      @pytest.fixture
+      def sample():
+          return 1
+      """;
+    PythonQuickFixVerifier.verifySemantic(CHECK, FILE_NAME, before, after);
+    PythonQuickFixVerifier.verifySemanticQuickFixMessages(CHECK, FILE_NAME, before, "Remove the empty parentheses");
+  }
+
+  @ParameterizedTest
+  @MethodSource("removalQuickFixCases")
+  void quick_fix_removes_empty_parentheses_of(String before, String after) {
+    PythonQuickFixVerifier.verifySemantic(CHECK, FILE_NAME, before, after);
+  }
+
+  static Stream removalQuickFixCases() {
+    return Stream.of(
+      Arguments.of("""
+        import pytest
+
+        @pytest.mark.slow()
+        def test_sample():
+            assert True
+        """, """
+        import pytest
+
+        @pytest.mark.slow
+        def test_sample():
+            assert True
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture ()
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture
+        def sample():
+            return 1
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(
+        )
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture
+        def sample():
+            return 1
+        """));
+  }
+
+  @Test
+  void no_quick_fix_when_a_comment_sits_inside_the_parentheses() {
+    String before = """
+      import pytest
+
+      @pytest.fixture(
+          # TODO decide on a scope
+      )
+      def sample():
+          return 1
+      """;
+    PythonQuickFixVerifier.verifySemanticNoQuickFixes(CHECK, FILE_NAME, before);
+  }
+
+  @Test
+  void quick_fix_adds_empty_parentheses() {
+    String before = """
+      import pytest
+
+      @pytest.fixture
+      def sample():
+          return 1
+      """;
+    String after = """
+      import pytest
+
+      @pytest.fixture()
+      def sample():
+          return 1
+      """;
+    PythonQuickFixVerifier.verifySemantic(checkRequiringParentheses(), FILE_NAME, before, after);
+    PythonQuickFixVerifier.verifySemanticQuickFixMessages(checkRequiringParentheses(), FILE_NAME, before, "Add empty parentheses");
+  }
+
+  @Test
+  void quick_fix_adds_empty_parentheses_to_mark() {
+    String before = """
+      import pytest
+
+      @pytest.mark.slow
+      def test_sample():
+          assert True
+      """;
+    String after = """
+      import pytest
+
+      @pytest.mark.slow()
+      def test_sample():
+          assert True
+      """;
+    PythonQuickFixVerifier.verifySemantic(checkRequiringParentheses(), FILE_NAME, before, after);
+  }
+
+  private static PytestDecoratorParenthesesCheck checkRequiringParentheses() {
+    PytestDecoratorParenthesesCheck check = new PytestDecoratorParenthesesCheck();
+    check.requireParentheses = true;
+    return check;
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestDefaultFixtureScopeCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestDefaultFixtureScopeCheckTest.java
new file mode 100644
index 0000000000..16b9c0217c
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestDefaultFixtureScopeCheckTest.java
@@ -0,0 +1,197 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestDefaultFixtureScopeCheckTest {
+
+  private static final String FILE_NAME = "test_pytest_default_fixture_scope.py";
+  private static final PytestDefaultFixtureScopeCheck CHECK = new PytestDefaultFixtureScopeCheck();
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestDefaultFixtureScope.py", CHECK);
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(CHECK.scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void quick_fix_message() {
+    String before = """
+      import pytest
+
+      @pytest.fixture(scope="function")
+      def sample():
+          return 1
+      """;
+    PythonQuickFixVerifier.verifySemanticQuickFixMessages(CHECK, FILE_NAME, before, "Remove scope=\"function\"");
+  }
+
+  @ParameterizedTest
+  @MethodSource("quickFixCases")
+  void quick_fix(String before, String after) {
+    PythonQuickFixVerifier.verifySemantic(CHECK, FILE_NAME, before, after);
+  }
+
+  static Stream quickFixCases() {
+    return Stream.of(
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(scope="function")
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture
+        def sample():
+            return 1
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(scope="function", autouse=True)
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture(autouse=True)
+        def sample():
+            return 1
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(autouse=True, scope="function")
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture(autouse=True)
+        def sample():
+            return 1
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(name="renamed", scope="function", autouse=True)
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture(name="renamed", autouse=True)
+        def sample():
+            return 1
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(autouse=True, scope="function",)
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture(autouse=True)
+        def sample():
+            return 1
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(
+            name="renamed",
+            scope="function",
+            autouse=True)
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture(
+            name="renamed",
+            autouse=True)
+        def sample():
+            return 1
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(
+            scope="function",
+            autouse=True)
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture(
+            autouse=True)
+        def sample():
+            return 1
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(
+            name="renamed",
+            scope="function")
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture(
+            name="renamed")
+        def sample():
+            return 1
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture(scope="function",
+            autouse=True)
+        def sample():
+            return 1
+        """, """
+        import pytest
+
+        @pytest.fixture(autouse=True)
+        def sample():
+            return 1
+        """)
+    );
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestFixtureMultipleYieldCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestFixtureMultipleYieldCheckTest.java
new file mode 100644
index 0000000000..6e42ab31a0
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestFixtureMultipleYieldCheckTest.java
@@ -0,0 +1,41 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestFixtureMultipleYieldCheckTest {
+
+  @Test
+  void scope() {
+    assertThat(new PytestFixtureMultipleYieldCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestFixtureMultipleYield.py", new PytestFixtureMultipleYieldCheck());
+  }
+
+  @Test
+  void nonFixtureGeneratorsAreIgnored() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/pytestFixtureMultipleYieldNonFixture.py", new PytestFixtureMultipleYieldCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestFixturePositionalArgsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestFixturePositionalArgsCheckTest.java
new file mode 100644
index 0000000000..a91b5d0ec9
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestFixturePositionalArgsCheckTest.java
@@ -0,0 +1,37 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestFixturePositionalArgsCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestFixturePositionalArgs.py", new PytestFixturePositionalArgsCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new PytestFixturePositionalArgsCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestFixtureYieldTeardownCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestFixtureYieldTeardownCheckTest.java
new file mode 100644
index 0000000000..053755fdfe
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestFixtureYieldTeardownCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestFixtureYieldTeardownCheckTest {
+
+  @Test
+  void scope() {
+    assertThat(new PytestFixtureYieldTeardownCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestFixtureYieldTeardown.py", new PytestFixtureYieldTeardownCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestModuleImportCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestModuleImportCheckTest.java
new file mode 100644
index 0000000000..48dd13e60d
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestModuleImportCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestModuleImportCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestModuleImport.py", new PytestModuleImportCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new PytestModuleImportCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestParameterDefaultValueCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestParameterDefaultValueCheckTest.java
new file mode 100644
index 0000000000..c239aed03f
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestParameterDefaultValueCheckTest.java
@@ -0,0 +1,158 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestParameterDefaultValueCheckTest {
+
+  private static final String FILE_NAME = "test_pytest_parameter_default_value.py";
+  private static final PytestParameterDefaultValueCheck CHECK = new PytestParameterDefaultValueCheck();
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/test_pytestParameterDefaultValue.py", CHECK);
+  }
+
+  @Test
+  void test_fixtures_in_conftest() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/conftest_pytestParameterDefaultValue.py", CHECK);
+  }
+
+  @Test
+  void test_no_issue_in_non_pytest_file() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/pytestParameterDefaultValueNonPytestFile.py", CHECK);
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(CHECK.scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void quick_fix_message() {
+    String before = """
+      import pytest
+
+      @pytest.fixture
+      def value():
+          return 42
+
+      def test_with_default(value=1):
+          assert value > 0
+      """;
+    PythonQuickFixVerifier.verifySemanticQuickFixMessages(CHECK, FILE_NAME, before, "Remove default value");
+  }
+
+  @ParameterizedTest
+  @MethodSource("quickFixCases")
+  void quick_fix(String before, String after) {
+    PythonQuickFixVerifier.verifySemantic(CHECK, FILE_NAME, before, after);
+  }
+
+  static Stream quickFixCases() {
+    return Stream.of(
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture
+        def value():
+            return 42
+
+        def test_with_default(value=1):
+            assert value > 0
+        """, """
+        import pytest
+
+        @pytest.fixture
+        def value():
+            return 42
+
+        def test_with_default(value):
+            assert value > 0
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture
+        def value():
+            return 42
+
+        def test_typed_default(value: int = 1):
+            assert value > 0
+        """, """
+        import pytest
+
+        @pytest.fixture
+        def value():
+            return 42
+
+        def test_typed_default(value: int):
+            assert value > 0
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture
+        def dep():
+            return 0
+
+        @pytest.fixture
+        def fixture_with_default(dep=1):
+            return dep
+        """, """
+        import pytest
+
+        @pytest.fixture
+        def dep():
+            return 0
+
+        @pytest.fixture
+        def fixture_with_default(dep):
+            return dep
+        """),
+      Arguments.of("""
+        import pytest
+
+        @pytest.fixture
+        def value():
+            return 42
+
+        def test_none_default(value=None):
+            assert value is None
+        """, """
+        import pytest
+
+        @pytest.fixture
+        def value():
+            return 42
+
+        def test_none_default(value):
+            assert value is None
+        """)
+    );
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestPluginsConftestCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestPluginsConftestCheckTest.java
new file mode 100644
index 0000000000..30b55474b3
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestPluginsConftestCheckTest.java
@@ -0,0 +1,59 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestPluginsConftestCheckTest {
+
+  private static final PytestPluginsConftestCheck CHECK = new PytestPluginsConftestCheck();
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/test_pytestPluginsConftest.py", CHECK);
+  }
+
+  @ParameterizedTest
+  @ValueSource(strings = {
+    "src/test/resources/checks/tests/conftestPlugins/conftest.py",
+    "src/test/resources/checks/pytestPluginsNonTestModule.py"
+  })
+  void compliant_files(String path) {
+    PythonCheckVerifier.verifyNoIssue(path, CHECK);
+  }
+
+  @Test
+  void init_py_in_test_package() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/package/__init__.py", CHECK);
+  }
+
+  @Test
+  void conftest_like_filename_is_not_compliant() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/conftestLikeFilenames/conftest_utils.py", CHECK);
+  }
+
+  @Test
+  void scope() {
+    assertThat(CHECK.scope()).isEqualTo(PythonCheck.CheckScope.TESTS);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestRaisesContextManagerCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestRaisesContextManagerCheckTest.java
new file mode 100644
index 0000000000..f9621820ae
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestRaisesContextManagerCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class PytestRaisesContextManagerCheckTest {
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new PytestRaisesContextManagerCheck().scope());
+  }
+
+  @Test
+  void sample() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestRaisesContextManager.py", new PytestRaisesContextManagerCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/PytestUselessYieldFixtureCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestUselessYieldFixtureCheckTest.java
new file mode 100644
index 0000000000..892b20a020
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/PytestUselessYieldFixtureCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PytestUselessYieldFixtureCheckTest {
+
+  @Test
+  void scope() {
+    assertThat(new PytestUselessYieldFixtureCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/pytestUselessYieldFixture.py", new PytestUselessYieldFixtureCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/SingleInvocationRuntimeExceptionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/SingleInvocationRuntimeExceptionCheckTest.java
new file mode 100644
index 0000000000..1c20ecd7ea
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/SingleInvocationRuntimeExceptionCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class SingleInvocationRuntimeExceptionCheckTest {
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new SingleInvocationRuntimeExceptionCheck().scope());
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/singleInvocationRuntimeException.py", new SingleInvocationRuntimeExceptionCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/SingleInvocationWarningCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/SingleInvocationWarningCheckTest.java
new file mode 100644
index 0000000000..514fd984b3
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/SingleInvocationWarningCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class SingleInvocationWarningCheckTest {
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new SingleInvocationWarningCheck().scope());
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/singleInvocationWarning.py", new SingleInvocationWarningCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/SkippedTestNoReasonCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/SkippedTestNoReasonCheckTest.java
index 4ed6000768..0eae23aaea 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/tests/SkippedTestNoReasonCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/SkippedTestNoReasonCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/SpecificExceptionAssertionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/SpecificExceptionAssertionCheckTest.java
new file mode 100644
index 0000000000..d7c7544d2a
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/SpecificExceptionAssertionCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class SpecificExceptionAssertionCheckTest {
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new SpecificExceptionAssertionCheck().scope());
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/specificExceptionAssertion.py", new SpecificExceptionAssertionCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/SpecificWarningAssertionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/SpecificWarningAssertionCheckTest.java
new file mode 100644
index 0000000000..06cfd9043b
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/SpecificWarningAssertionCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class SpecificWarningAssertionCheckTest {
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new SpecificWarningAssertionCheck().scope());
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/specificWarningAssertion.py", new SpecificWarningAssertionCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/TestCasesShouldContainTestsCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/TestCasesShouldContainTestsCheckTest.java
new file mode 100644
index 0000000000..956e819573
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/TestCasesShouldContainTestsCheckTest.java
@@ -0,0 +1,61 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class TestCasesShouldContainTestsCheckTest {
+
+  @Test
+  void scope() {
+    assertThat(new TestCasesShouldContainTestsCheck().scope()).isEqualTo(PythonCheck.CheckScope.TESTS);
+  }
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/testCasesShouldContainTests_test.py", new TestCasesShouldContainTestsCheck());
+  }
+
+  @Test
+  void pytest_file_without_tests() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/emptyPytestModule_test.py", new TestCasesShouldContainTestsCheck());
+  }
+
+  @Test
+  void pytest_prefix_file_without_tests() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/test_emptyPytestModule.py", new TestCasesShouldContainTestsCheck());
+  }
+
+  @Test
+  void non_pytest_file() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/helpersOnlyModule.py", new TestCasesShouldContainTestsCheck());
+  }
+
+  @Test
+  void empty_file() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/emptyModule.py", new TestCasesShouldContainTestsCheck());
+  }
+
+  @Test
+  void file_with_class_tests_but_no_candidate_class() {
+    PythonCheckVerifier.verifyNoIssue("src/test/resources/checks/tests/test_fileWithClassTestsButNoCandidateClass.py", new TestCasesShouldContainTestsCheck());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/UnconditionalAssertionCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/UnconditionalAssertionCheckTest.java
index e8561487d7..0e6d0df17a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/tests/UnconditionalAssertionCheckTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/UnconditionalAssertionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/UseMonkeypatchFixtureCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/UseMonkeypatchFixtureCheckTest.java
new file mode 100644
index 0000000000..e1ba61dede
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/UseMonkeypatchFixtureCheckTest.java
@@ -0,0 +1,56 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class UseMonkeypatchFixtureCheckTest {
+
+  private static final String RESOURCES = "src/test/resources/checks/tests/";
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify(RESOURCES + "test_useMonkeypatchFixture.py", new UseMonkeypatchFixtureCheck());
+  }
+
+  @ParameterizedTest
+  @CsvSource({
+    "useMonkeypatchFixture.py, false",
+    "useMonkeypatchFixture_test.py, true",
+    "test_useMonkeypatchFixture_lifecycle.py, false"
+  })
+  void testFileNames(String fileName, boolean expectIssues) {
+    var check = new UseMonkeypatchFixtureCheck();
+    var path = RESOURCES + fileName;
+    if (expectIssues) {
+      PythonCheckVerifier.verify(path, check);
+    } else {
+      PythonCheckVerifier.verifyNoIssue(path, check);
+    }
+  }
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new UseMonkeypatchFixtureCheck().scope());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/UseTmpPathInsteadOfFactoryCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/UseTmpPathInsteadOfFactoryCheckTest.java
new file mode 100644
index 0000000000..f99626eafe
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/UseTmpPathInsteadOfFactoryCheckTest.java
@@ -0,0 +1,55 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class UseTmpPathInsteadOfFactoryCheckTest {
+
+  private static final String RESOURCES = "src/test/resources/checks/tests/";
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify(RESOURCES + "test_useTmpPathInsteadOfFactory.py", new UseTmpPathInsteadOfFactoryCheck());
+  }
+
+  @ParameterizedTest
+  @CsvSource({
+    "useTmpPathInsteadOfFactory.py, false",
+    "useTmpPathInsteadOfFactory_test.py, true"
+  })
+  void testFileNames(String fileName, boolean expectIssues) {
+    var check = new UseTmpPathInsteadOfFactoryCheck();
+    var path = RESOURCES + fileName;
+    if (expectIssues) {
+      PythonCheckVerifier.verify(path, check);
+    } else {
+      PythonCheckVerifier.verifyNoIssue(path, check);
+    }
+  }
+
+  @Test
+  void scope() {
+    assertEquals(PythonCheck.CheckScope.ALL, new UseTmpPathInsteadOfFactoryCheck().scope());
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/UselessPytestMarksCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/UselessPytestMarksCheckTest.java
new file mode 100644
index 0000000000..b5a97d3b9a
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/UselessPytestMarksCheckTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class UselessPytestMarksCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/uselessPytestMarks.py", new UselessPytestMarksCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new UselessPytestMarksCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/tests/XfailNoReasonCheckTest.java b/python-checks/src/test/java/org/sonar/python/checks/tests/XfailNoReasonCheckTest.java
new file mode 100644
index 0000000000..e69442ad5c
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/tests/XfailNoReasonCheckTest.java
@@ -0,0 +1,42 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.tests;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class XfailNoReasonCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/xfailNoReason.py", new XfailNoReasonCheck());
+  }
+
+  @Test
+  void testWithImport() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tests/xfailNoReasonWithImport.py", new XfailNoReasonCheck());
+  }
+
+  @Test
+  void test_scope() {
+    assertThat(new XfailNoReasonCheck().scope()).isEqualTo(PythonCheck.CheckScope.ALL);
+  }
+
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/utils/AwsLambdaChecksUtilsTest.java b/python-checks/src/test/java/org/sonar/python/checks/utils/AwsLambdaChecksUtilsTest.java
index 8ca30e5854..ab8a0deb3e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/utils/AwsLambdaChecksUtilsTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/utils/AwsLambdaChecksUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.checks.utils;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.SubscriptionContext;
 import org.sonar.plugins.python.api.project.configuration.AwsLambdaHandlerInfo;
 import org.sonar.plugins.python.api.project.configuration.ProjectConfiguration;
@@ -32,6 +31,8 @@
 import org.sonar.python.tree.PythonTreeMaker;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class AwsLambdaChecksUtilsTest {
   @Test
@@ -125,9 +126,9 @@ void isOnlyLambdaHandlerTest() {
   }
 
   private static SubscriptionContext subscriptionContext(CallGraph callGraph) {
-    var subscriptionContext = Mockito.mock(org.sonar.plugins.python.api.SubscriptionContext.class);
-    Mockito.when(subscriptionContext.projectConfiguration()).thenReturn(new ProjectConfiguration());
-    Mockito.when(subscriptionContext.callGraph()).thenReturn(callGraph);
+    var subscriptionContext = mock(org.sonar.plugins.python.api.SubscriptionContext.class);
+    when(subscriptionContext.projectConfiguration()).thenReturn(new ProjectConfiguration());
+    when(subscriptionContext.callGraph()).thenReturn(callGraph);
 
     return subscriptionContext;
   }
@@ -138,17 +139,17 @@ private static FunctionDef functionDef(String name) {
   }
 
   private static FunctionType functionType(String name) {
-    FunctionType functionNameType = Mockito.mock(FunctionType.class);
-    Mockito.when(functionNameType.fullyQualifiedName()).thenReturn(name);
+    FunctionType functionNameType = mock(FunctionType.class);
+    when(functionNameType.fullyQualifiedName()).thenReturn(name);
     return functionNameType;
   }
 
   private static FunctionDef functionDef(PythonType type) {
-    Name functionName = Mockito.mock(Name.class);
-    FunctionDef functionDef = Mockito.mock(FunctionDef.class);
+    Name functionName = mock(Name.class);
+    FunctionDef functionDef = mock(FunctionDef.class);
 
-    Mockito.when(functionName.typeV2()).thenReturn(type);
-    Mockito.when(functionDef.name()).thenReturn(functionName);
+    when(functionName.typeV2()).thenReturn(type);
+    when(functionDef.name()).thenReturn(functionName);
     return functionDef;
   }
 
diff --git a/python-checks/src/test/java/org/sonar/python/checks/utils/CheckUtilsTest.java b/python-checks/src/test/java/org/sonar/python/checks/utils/CheckUtilsTest.java
index c131f271ed..1cc4dac95e 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/utils/CheckUtilsTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/utils/CheckUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/utils/CodeTestUtils.java b/python-checks/src/test/java/org/sonar/python/checks/utils/CodeTestUtils.java
index d0a9eb242f..9702772088 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/utils/CodeTestUtils.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/utils/CodeTestUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/java/org/sonar/python/checks/utils/ExpressionsTest.java b/python-checks/src/test/java/org/sonar/python/checks/utils/ExpressionsTest.java
index b476fd1702..37f9c22110 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/utils/ExpressionsTest.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/utils/ExpressionsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -37,8 +37,10 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.sonar.python.checks.utils.Expressions.containsSpreadOperator;
+import static org.sonar.python.checks.utils.Expressions.expressionsFromListOrTuple;
 import static org.sonar.python.checks.utils.Expressions.getAssignedName;
 import static org.sonar.python.checks.utils.Expressions.isFalsy;
+import static org.sonar.python.checks.utils.Expressions.isBuiltinTypeAssignment;
 import static org.sonar.python.checks.utils.Expressions.isTruthy;
 import static org.sonar.python.checks.utils.Expressions.removeParentheses;
 import static org.sonar.python.checks.utils.Expressions.unescape;
@@ -116,6 +118,16 @@ void remove_parentheses() {
     assertThat(removeParentheses(exp("((a))")).getKind()).isEqualTo(Kind.NAME);
   }
 
+  @Test
+  void builtin_type_assignments() {
+    assertThat(isBuiltinTypeAssignment(expWithSemantics("type(role)"))).isTrue();
+    assertThat(isBuiltinTypeAssignment(expWithSemantics("type(role) if x else None"))).isTrue();
+    assertThat(isBuiltinTypeAssignment(expWithSemantics("None if x else type(role)"))).isTrue();
+    assertThat(isBuiltinTypeAssignment(expWithSemantics("type(role) if x else 42"))).isFalse();
+    assertThat(isBuiltinTypeAssignment(expWithSemantics("42 if x else type(role)"))).isFalse();
+    assertThat(isBuiltinTypeAssignment(expWithSemantics("None if x else None"))).isFalse();
+  }
+
   @Test
   void unescape_string_literal() {
     assertThat(unescape(stringLiteral("''"))).isEmpty();
@@ -226,6 +238,14 @@ void testContainsSpreadOperator() {
     assertThat(containsSpreadOperator(args("some()"))).isFalse();
   }
 
+  @Test
+  void expressionsFromListOrTuple_list_tuple_set_and_other() {
+    assertThat(expressionsFromListOrTuple(exp("[1, 2, 3]"))).hasSize(3);
+    assertThat(expressionsFromListOrTuple(exp("(1, 2, 3)"))).hasSize(3);
+    assertThat(expressionsFromListOrTuple(exp("{1, 2, 3}"))).hasSize(3);
+    assertThat(expressionsFromListOrTuple(exp("42"))).isEmpty();
+  }
+
   private List args(String source) {
     Expression callExpr = exp(source);
     assertThat(callExpr).isInstanceOf(CallExpression.class);
@@ -244,6 +264,12 @@ private Expression exp(String code) {
     return exp(parse(code));
   }
 
+  private Expression expWithSemantics(String code) {
+    FileInput root = parse(code);
+    new SymbolTableBuilder(null).visitFileInput(root);
+    return exp(root);
+  }
+
   private Expression exp(Tree tree) {
     if (tree instanceof Expression expression) {
       return expression;
diff --git a/python-checks/src/test/java/org/sonar/python/checks/utils/GeneratedFileUtilsTest.java b/python-checks/src/test/java/org/sonar/python/checks/utils/GeneratedFileUtilsTest.java
new file mode 100644
index 0000000000..9c28dedab4
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/utils/GeneratedFileUtilsTest.java
@@ -0,0 +1,64 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.utils;
+
+import com.sonar.sslr.api.AstNode;
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonFile;
+import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.python.TestPythonVisitorRunner;
+import org.sonar.python.parser.PythonParser;
+import org.sonar.python.tree.PythonTreeMaker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class GeneratedFileUtilsTest {
+
+  @Test
+  void isGeneratedFileForReadabilityRules_detects_protobuf_generated_files() {
+    String code = "# Generated by the protocol buffer compiler.\nx = 1";
+    FileInput fileInput = parse(code);
+
+    assertThat(GeneratedFileUtils.isGeneratedFileForReadabilityRules(pythonFile("service/user_pb2.py", code), fileInput)).isTrue();
+    assertThat(GeneratedFileUtils.isGeneratedFileForReadabilityRules(pythonFile("service/user_pb2_grpc.py", code), fileInput)).isTrue();
+    assertThat(GeneratedFileUtils.isGeneratedFileForReadabilityRules(pythonFile("service/user_pb2_test.py", code), fileInput)).isFalse();
+  }
+
+  @Test
+  void isGeneratedFileForReadabilityRules_detects_grpc_generated_files() {
+    String code = "# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!\nx = 1";
+    FileInput fileInput = parse(code);
+
+    assertThat(GeneratedFileUtils.isGeneratedFileForReadabilityRules(pythonFile("service/user_pb2_grpc.py", code), fileInput)).isTrue();
+  }
+
+  @Test
+  void isGeneratedFileForReadabilityRules_requires_protobuf_generated_header() {
+    FileInput fileInput = parse("x = 1");
+
+    assertThat(GeneratedFileUtils.isGeneratedFileForReadabilityRules(pythonFile("service/user_pb2.py", "x = 1"), fileInput)).isFalse();
+  }
+
+  private static PythonFile pythonFile(String path, String content) {
+    return new TestPythonVisitorRunner.MockPythonFile("", path, content);
+  }
+
+  private static FileInput parse(String code) {
+    AstNode astNode = PythonParser.create().parse(code);
+    return new PythonTreeMaker().fileInput(astNode);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/utils/MarimoUtilsTest.java b/python-checks/src/test/java/org/sonar/python/checks/utils/MarimoUtilsTest.java
new file mode 100644
index 0000000000..01f0af741b
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/utils/MarimoUtilsTest.java
@@ -0,0 +1,87 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.utils;
+
+import com.sonar.sslr.api.AstNode;
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.SubscriptionContext;
+import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.plugins.python.api.tree.FunctionDef;
+import org.sonar.python.TestPythonVisitorRunner;
+import org.sonar.python.parser.PythonParser;
+import org.sonar.python.semantic.ProjectLevelSymbolTable;
+import org.sonar.python.semantic.v2.SymbolTableBuilderV2;
+import org.sonar.python.semantic.v2.TypeInferenceV2;
+import org.sonar.python.semantic.v2.typetable.ProjectLevelTypeTable;
+import org.sonar.python.tree.PythonTreeMaker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class MarimoUtilsTest {
+
+  @Test
+  void isTreeInMarimoDecoratedFunction_returnsFalseWhenNotInsideFunction() {
+    FileInput fileInput = parse("""
+      import marimo
+      x = 1
+      """);
+
+    SubscriptionContext ctx = mockSubscriptionContext();
+
+    assertThat(MarimoUtils.isTreeInMarimoDecoratedFunction(fileInput, ctx)).isFalse();
+  }
+
+  @Test
+  void isTreeInMarimoDecoratedFunction_returnsTrueWhenInsideAppCellFunction() {
+    String content = """
+      import marimo
+      app = marimo.App()
+      @app.cell
+      def some_cell():
+          return 1
+      """;
+
+    FileInput fileInput = parse(content);
+    var typeTable = new ProjectLevelTypeTable(ProjectLevelSymbolTable.empty());
+    var mockFile = new TestPythonVisitorRunner.MockPythonFile("", "test.py", content);
+    var symbolTableV2 = new SymbolTableBuilderV2(fileInput).build();
+    new TypeInferenceV2(typeTable, mockFile, symbolTableV2, "").inferModuleType(fileInput);
+
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(typeTable);
+
+    var statements = fileInput.statements().statements();
+    var functionDef = (FunctionDef) statements.get(statements.size() - 1);
+    var returnStatement = functionDef.body().statements().get(0);
+
+    assertThat(MarimoUtils.isTreeInMarimoDecoratedFunction(returnStatement, ctx)).isTrue();
+  }
+
+  private static SubscriptionContext mockSubscriptionContext() {
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(new ProjectLevelTypeTable(ProjectLevelSymbolTable.empty()));
+    return ctx;
+  }
+
+  private static FileInput parse(String content) {
+    PythonParser parser = PythonParser.create();
+    AstNode astNode = parser.parse(content);
+    return new PythonTreeMaker().fileInput(astNode);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/utils/UnittestUtilsTest.java b/python-checks/src/test/java/org/sonar/python/checks/utils/UnittestUtilsTest.java
new file mode 100644
index 0000000000..4268a6e4f6
--- /dev/null
+++ b/python-checks/src/test/java/org/sonar/python/checks/utils/UnittestUtilsTest.java
@@ -0,0 +1,397 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiConsumer;
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.PythonSubscriptionCheck;
+import org.sonar.plugins.python.api.PythonVisitorContext;
+import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.ClassDef;
+import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.plugins.python.api.tree.FunctionDef;
+import org.sonar.plugins.python.api.tree.RegularArgument;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.python.SubscriptionVisitor;
+import org.sonar.python.TestPythonVisitorRunner;
+import org.sonar.python.parser.PythonParser;
+import org.sonar.python.semantic.ProjectLevelSymbolTable;
+import org.sonar.python.semantic.SymbolTableBuilder;
+import org.sonar.python.tree.PythonTreeMaker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.python.caching.CacheContextImpl.dummyCache;
+
+class UnittestUtilsTest {
+
+  @Test
+  void test_isWithinUnittestTestCase() {
+    String code = "import unittest\nclass A(unittest.TestCase):  ...";
+    FileInput fileInput = parse("mod1.py", code);
+    Tree tree = lastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
+    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isTrue();
+
+    code = "import unittest\nclass A(unittest.case.TestCase):  ...";
+    fileInput = parse("mod1.py", code);
+    tree = lastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
+    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isTrue();
+
+    code = "import random_wrapper\nclass A(random_wrapper.unittest.TestCase):  ...";
+    fileInput = parse("mod1.py", code);
+    tree = lastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
+    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isTrue();
+
+    code = "import random\nclass A(random.TestCase):  ...";
+    fileInput = parse("mod1.py", code);
+    tree = lastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
+    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isFalse();
+
+    code = "import unittest\nclass A(unittest.other):  ...";
+    fileInput = parse("mod1.py", code);
+    tree = lastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
+    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isFalse();
+
+    code = "...";
+    fileInput = parse("mod1.py", code);
+    tree = lastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
+    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isFalse();
+  }
+
+  @Test
+  void all_methods() {
+    assertThat(UnittestUtils.allMethods())
+      .hasSize(61)
+      .contains("skipTest")
+      .doesNotContain("skiptTest");
+  }
+
+  @Test
+  void all_assert_methods() {
+    assertThat(UnittestUtils.allAssertMethods()).hasSize(38);
+  }
+
+  @Test
+  void test_name_helpers() {
+    assertThat(UnittestUtils.isTestMethodName("test_something")).isTrue();
+    assertThat(UnittestUtils.isTestMethodName("helper")).isFalse();
+    assertThat(UnittestUtils.isTestClassName("TestSomething")).isTrue();
+    assertThat(UnittestUtils.isTestClassName("Helper")).isFalse();
+    assertThat(UnittestUtils.isPytestFileName("test_module.py")).isTrue();
+    assertThat(UnittestUtils.isPytestFileName("module_test.py")).isTrue();
+    assertThat(UnittestUtils.isPytestFileName("module.py")).isFalse();
+  }
+
+  @Test
+  void test_constructor_detection() {
+    FileInput fileInput = parse("test_module.py", """
+      class TestWithInit:
+        def __init__(self):
+          pass
+
+      class TestWithNew:
+        def __new__(cls):
+          return super().__new__(cls)
+
+      class TestWithoutConstructor:
+        def helper(self):
+          pass
+      """);
+
+    var classes = fileInput.statements().statements().stream()
+      .filter(ClassDef.class::isInstance)
+      .map(ClassDef.class::cast)
+      .toList();
+
+    assertThat(UnittestUtils.hasConstructor(classes.get(0))).isTrue();
+    assertThat(UnittestUtils.hasConstructor(classes.get(1))).isTrue();
+    assertThat(UnittestUtils.hasConstructor(classes.get(2))).isFalse();
+  }
+
+  @Test
+  void test_pytest_style_test_class() {
+    FileInput fileInput = parse("test_module.py", """
+      import pytest
+
+      class TestCollected:
+        @pytest.fixture()
+        def setup_data(self):
+          return 42
+
+        def test_ok(self):
+          pass
+
+      class TestWithInit:
+        def __init__(self):
+          pass
+
+      class TestWithSetUp:
+        def setUp(self):
+          pass
+
+      class Helper:
+        def test_ok(self):
+          pass
+      """);
+
+    var classes = fileInput.statements().statements().stream()
+      .filter(ClassDef.class::isInstance)
+      .map(ClassDef.class::cast)
+      .toList();
+
+    assertThat(UnittestUtils.isPytestStyleTestClass(classes.get(0), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isPytestStyleTestClass(classes.get(1), "test_module.py")).isFalse();
+    assertThat(UnittestUtils.isPytestStyleTestClass(classes.get(2), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isPytestStyleTestClass(classes.get(3), "test_module.py")).isFalse();
+  }
+
+  @Test
+  void test_pytest_style_test_function() {
+    FileInput fileInput = parse("test_module.py", """
+      def test_module_level():
+        pass
+
+      class TestContainer:
+        def test_in_class(self):
+          pass
+
+      class Helper:
+        def test_helper(self):
+          pass
+
+        def wrapper(self):
+          def test_nested():
+            pass
+          return test_nested
+
+      def helper():
+        pass
+      """);
+
+    var functions = allDescendants(fileInput, t -> t.is(Tree.Kind.FUNCDEF)).stream()
+      .map(FunctionDef.class::cast)
+      .toList();
+
+    assertThat(UnittestUtils.isPytestStyleTestFunction(functions.get(0), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isPytestStyleTestFunction(functions.get(1), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isPytestStyleTestFunction(functions.get(2), "test_module.py")).isFalse();
+    assertThat(UnittestUtils.isPytestStyleTestFunction(functions.get(3), "test_module.py")).isFalse();
+    assertThat(UnittestUtils.isPytestStyleTestFunction(functions.get(4), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isPytestStyleTestFunction(functions.get(5), "test_module.py")).isFalse();
+    assertThat(UnittestUtils.isPytestStyleTestFunction(functions.get(0), "module.py")).isFalse();
+  }
+
+  @Test
+  void test_collected_pytest_test_function() {
+    FileInput fileInput = parse("test_module.py", """
+      def test_module_level():
+        pass
+
+      class ComparisonTest:
+        def test_in_comparison_test(self):
+          pass
+
+      class DigestAuthTests:
+        def test_in_tests_suffix(self):
+          pass
+
+      class RemoteFuncsTestCase:
+        def test_in_testcase(self):
+          pass
+
+      class test_celery_style:
+        def test_in_celery_class(self):
+          pass
+
+      class Helper:
+        def test_helper(self):
+          pass
+
+        def wrapper(self):
+          def test_nested():
+            pass
+          return test_nested
+      """);
+
+    var functionsByName = allDescendants(fileInput, t -> t.is(Tree.Kind.FUNCDEF)).stream()
+      .map(FunctionDef.class::cast)
+      .collect(java.util.stream.Collectors.toMap(f -> f.name().name(), f -> f, (a, b) -> a));
+
+    assertThat(UnittestUtils.isCollectedPytestTestFunction(functionsByName.get("test_module_level"), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isCollectedPytestTestFunction(functionsByName.get("test_in_comparison_test"), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isCollectedPytestTestFunction(functionsByName.get("test_in_tests_suffix"), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isCollectedPytestTestFunction(functionsByName.get("test_in_testcase"), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isCollectedPytestTestFunction(functionsByName.get("test_in_celery_class"), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isCollectedPytestTestFunction(functionsByName.get("test_helper"), "test_module.py")).isFalse();
+    assertThat(UnittestUtils.isCollectedPytestTestFunction(functionsByName.get("test_nested"), "test_module.py")).isTrue();
+    assertThat(UnittestUtils.isCollectedPytestTestFunction(functionsByName.get("test_module_level"), "module.py")).isFalse();
+  }
+
+  @Test
+  void test_pytest_lifecycle_methods() {
+    FileInput fileInput = parse("test_module.py", """
+      import pytest
+
+      class TestFixtureBased:
+        @pytest.fixture(scope="module")
+        def setup_data(self):
+          return 42
+
+      class TestTearDownBased:
+        def tearDown(self):
+          pass
+
+      class TestXunitBased:
+        def teardown_method(self):
+          pass
+
+      class TestWithoutLifecycle:
+        def helper(self):
+          pass
+      """);
+
+    var classes = fileInput.statements().statements().stream()
+      .filter(ClassDef.class::isInstance)
+      .map(ClassDef.class::cast)
+      .toList();
+
+    assertThat(UnittestUtils.hasPytestLifecycleMethods(classes.get(0))).isTrue();
+    assertThat(UnittestUtils.hasPytestLifecycleMethods(classes.get(1))).isTrue();
+    assertThat(UnittestUtils.hasPytestLifecycleMethods(classes.get(2))).isTrue();
+    assertThat(UnittestUtils.hasPytestLifecycleMethods(classes.get(3))).isFalse();
+  }
+
+  @Test
+  void test_isUnittestTestCaseClass() {
+    String code = "import unittest\nclass A(unittest.TestCase):\n  ...";
+    FileInput fileInput = parse("mod1.py", code);
+    ClassDef classDef = (ClassDef) fileInput.statements().statements().get(1);
+    assertThat(UnittestUtils.isUnittestTestCaseClass(classDef)).isTrue();
+
+    code = "import random\nclass A(random.TestCase):\n  ...";
+    fileInput = parse("mod1.py", code);
+    classDef = (ClassDef) fileInput.statements().statements().get(1);
+    assertThat(UnittestUtils.isUnittestTestCaseClass(classDef)).isFalse();
+  }
+
+  @Test
+  void test_pytest_raises_helpers() {
+    List isPytestRaises = new ArrayList<>();
+    List hasMatchArgument = new ArrayList<>();
+    List exceptionArguments = new ArrayList<>();
+
+    analyzeCallExpressions("""
+      import pytest
+      from pytest import raises
+      pytest.raises(Exception, match="bad")
+      raises(ValueError)
+      """, (ctx, callExpression) -> {
+      isPytestRaises.add(UnittestUtils.isPytestRaises(callExpression, ctx));
+      hasMatchArgument.add(UnittestUtils.pytestMatchArgument(callExpression) != null);
+      exceptionArguments.add(UnittestUtils.pytestExpectedExceptionArgument(callExpression).expression().firstToken().value());
+    });
+
+    assertThat(isPytestRaises).containsExactly(true, true);
+    assertThat(hasMatchArgument).containsExactly(true, false);
+    assertThat(exceptionArguments).containsExactly("Exception", "ValueError");
+  }
+
+  @Test
+  void test_pytest_warns_helpers() {
+    List isPytestWarns = new ArrayList<>();
+    List hasMatchArgument = new ArrayList<>();
+    List warningArguments = new ArrayList<>();
+    List matchArguments = new ArrayList<>();
+
+    analyzeCallExpressions("""
+      import pytest
+      from pytest import warns
+      pytest.warns(Warning, match="bad")
+      warns(UserWarning)
+      """, (ctx, callExpression) -> {
+      isPytestWarns.add(UnittestUtils.isPytestWarns(callExpression, ctx));
+      hasMatchArgument.add(UnittestUtils.pytestMatchArgument(callExpression) != null);
+      warningArguments.add(UnittestUtils.pytestExpectedWarningArgument(callExpression).expression().firstToken().value());
+      RegularArgument matchArgument = UnittestUtils.pytestMatchArgument(callExpression);
+      matchArguments.add(matchArgument == null ? null : matchArgument.expression().firstToken().value());
+    });
+
+    assertThat(isPytestWarns).containsExactly(true, true);
+    assertThat(hasMatchArgument).containsExactly(true, false);
+    assertThat(warningArguments).containsExactly("Warning", "UserWarning");
+    assertThat(matchArguments).containsExactly("\"bad\"", null);
+  }
+
+  @Test
+  void test_unittest_assert_raises_helpers() {
+    List isAssertRaises = new ArrayList<>();
+    List hasMessageCheck = new ArrayList<>();
+    List exceptionArguments = new ArrayList<>();
+
+    analyzeCallExpressions("""
+      import unittest
+
+      class MyTest(unittest.TestCase):
+        def test_ok(self):
+          self.assertRaises(Exception, explode)
+          self.assertRaisesRegex(Exception, "bad", explode)
+      """, (ctx, callExpression) -> {
+      isAssertRaises.add(UnittestUtils.isUnittestAssertRaises(callExpression, ctx));
+      hasMessageCheck.add(UnittestUtils.hasUnittestAssertRaisesMessageCheck(callExpression, ctx));
+      exceptionArguments.add(UnittestUtils.unittestExceptionArgument(callExpression).expression().firstToken().value());
+    });
+
+    assertThat(isAssertRaises).containsExactly(true, true);
+    assertThat(hasMessageCheck).containsExactly(false, true);
+    assertThat(exceptionArguments).containsExactly("Exception", "Exception");
+  }
+
+  private static FileInput parse(String fileName, String code) {
+    FileInput fileInput = new PythonTreeMaker().fileInput(PythonParser.create().parse(code));
+    new SymbolTableBuilder("", new TestPythonVisitorRunner.MockPythonFile("", fileName, code)).visitFileInput(fileInput);
+    return fileInput;
+  }
+
+  private static void analyzeCallExpressions(String code, BiConsumer consumer) {
+    var file = new TestPythonVisitorRunner.MockPythonFile("", "mod1.py", code);
+    PythonVisitorContext context = TestPythonVisitorRunner.createContext(file, null, "", ProjectLevelSymbolTable.empty(), dummyCache());
+    PythonSubscriptionCheck check = new PythonSubscriptionCheck() {
+      @Override
+      public void initialize(Context context) {
+        context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> consumer.accept(ctx, (CallExpression) ctx.syntaxNode()));
+      }
+    };
+    SubscriptionVisitor.analyze(List.of(check), context);
+  }
+
+  private static  List allDescendants(Tree tree, java.util.function.Predicate predicate) {
+    List result = new ArrayList<>();
+    for (Tree child : tree.children()) {
+      if (predicate.test(child)) {
+        result.add((T) child);
+      }
+      result.addAll(allDescendants(child, predicate));
+    }
+    return result;
+  }
+
+  private static  T lastDescendant(Tree tree, java.util.function.Predicate predicate) {
+    List descendants = allDescendants(tree, predicate);
+    return descendants.get(descendants.size() - 1);
+  }
+}
diff --git a/python-checks/src/test/java/org/sonar/python/checks/utils/package-info.java b/python-checks/src/test/java/org/sonar/python/checks/utils/package-info.java
index 8634f7f6de..ff19e08b7a 100644
--- a/python-checks/src/test/java/org/sonar/python/checks/utils/package-info.java
+++ b/python-checks/src/test/java/org/sonar/python/checks/utils/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-checks/src/test/resources/checks/afterJumpStatement.py b/python-checks/src/test/resources/checks/afterJumpStatement.py
index 5c5895a25c..bd0f1dbbc9 100644
--- a/python-checks/src/test/resources/checks/afterJumpStatement.py
+++ b/python-checks/src/test/resources/checks/afterJumpStatement.py
@@ -223,4 +223,4 @@ def match_statement_fn(value):
   match value:
     case "1": return
     case x: return
-  print("unreachable")  # FN, "case x" will match anything
+  print("unreachable")  # Noncompliant
diff --git a/python-checks/src/test/resources/checks/argumentNumber.py b/python-checks/src/test/resources/checks/argumentNumber.py
index ab56f68705..a13cc353a2 100644
--- a/python-checks/src/test/resources/checks/argumentNumber.py
+++ b/python-checks/src/test/resources/checks/argumentNumber.py
@@ -160,7 +160,7 @@ def __reduce__(self, p1, p2):
     class B2(B1):
       def foo(self):
         super().__reduce__(1, 2) # OK, __reduce__ is not 'object.__reduce__' but B1.__reduce__
-        super().__reduce__(1, 2, 3) # FN
+        super().__reduce__(1, 2, 3) # Noncompliant
 
     class MethodsWithKeywordArguments:
         @classmethod
@@ -318,3 +318,9 @@ def some_method(self, param): ...
 def torch():
     import torch
     torch.cat(torch.Tensor(), axis=-1)
+
+def pandas():
+    import pandas as pd
+    pd.testing.assert_index_equal(left_index, right_index, check_names=False)
+    df = pd.DataFrame()
+    df.stack("MASTER_FND_CODE", future_stack=True)
diff --git a/python-checks/src/test/resources/checks/asyncFunctionNotAsync.py b/python-checks/src/test/resources/checks/asyncFunctionNotAsync.py
index cae5813e90..7b18456143 100644
--- a/python-checks/src/test/resources/checks/asyncFunctionNotAsync.py
+++ b/python-checks/src/test/resources/checks/asyncFunctionNotAsync.py
@@ -189,3 +189,92 @@ async def async_comprehension():
 
 async def sync_comprehension(): # Noncompliant
     return [something for something in async_iterable()]
+
+
+# httpx.AsyncClient event hooks - coroutine callbacks are required
+import httpx
+
+async def validate_response(response: httpx.Response) -> None:  # Compliant - registered as AsyncClient hook
+    validate_url(response.url)
+
+async def validate_request(request: httpx.Request) -> None:  # Compliant - registered as AsyncClient hook
+    validate_headers(request.headers)
+
+async def both_hooks(response: httpx.Response) -> None:  # Compliant - used in both hooks
+    do_something()
+
+async_client = httpx.AsyncClient(
+    event_hooks={
+        "request": [validate_request, both_hooks],
+        "response": [validate_response, both_hooks],
+    }
+)
+
+class CustomAsyncClient(httpx.AsyncClient):
+    pass
+
+async def subclass_hook(response: httpx.Response) -> None:  # Compliant - registered as subclass of AsyncClient hook
+    validate_url(response.url)
+
+CustomAsyncClient(event_hooks={"response": [subclass_hook]})
+
+async def sync_client_hook(response: httpx.Response) -> None:  # Noncompliant
+    validate_url(response.url)
+
+sync_client = httpx.Client(
+    event_hooks={"response": [sync_client_hook]}
+)
+
+async def unrelated_hook(response) -> None:  # Noncompliant
+    validate_url(response.url)
+
+async def hook_no_event_hooks_kwarg(response) -> None:  # Noncompliant
+    validate_url(response.url)
+
+httpx.AsyncClient(timeout=hook_no_event_hooks_kwarg)  # no event_hooks kwarg
+
+# FP: function is an event hook, but event_hooks is passed as a variable; variable indirection cannot be tracked
+async def hook_via_variable(response) -> None:  # Noncompliant
+    validate_url(response.url)
+
+hooks_dict = {"response": [hook_via_variable]}
+httpx.AsyncClient(event_hooks=hooks_dict)
+
+
+# confluent_kafka.aio.AIOConsumer.subscribe - coroutine callbacks are required
+from confluent_kafka.aio import AIOConsumer
+
+consumer = AIOConsumer({"bootstrap.servers": "localhost:9092", "group.id": "mygroup"})
+
+async def on_assign_handler(consumer, partitions) -> None:  # Compliant - registered as AIOConsumer.subscribe callback
+    logger.info("Partitions assigned: %s", partitions)
+
+async def on_revoke_handler(consumer, partitions) -> None:  # Compliant - registered as AIOConsumer.subscribe callback
+    logger.info("Partitions revoked: %s", partitions)
+
+async def on_lost_handler(consumer, partitions) -> None:  # Compliant - registered as AIOConsumer.subscribe callback
+    logger.info("Partitions lost: %s", partitions)
+
+await consumer.subscribe(
+    ["topic"],
+    on_assign=on_assign_handler,
+    on_revoke=on_revoke_handler,
+    on_lost=on_lost_handler,
+)
+
+async def unrelated_subscribe_callback(consumer, partitions) -> None:  # Noncompliant
+    logger.info("Partitions: %s", partitions)
+
+unknown_obj.subscribe(on_assign=unrelated_subscribe_callback)
+
+# FP: callback is passed positionally as on_assign, but we only detect keyword arguments
+async def positional_subscribe_callback(consumer, partitions) -> None:  # Noncompliant
+    logger.info("Partitions: %s", partitions)
+
+await consumer.subscribe(["topic"], positional_subscribe_callback)
+
+# Passed via an unknown keyword argument (not on_assign/on_revoke/on_lost)
+async def unknown_kwarg_subscribe_callback(consumer, partitions) -> None:  # Noncompliant
+    logger.info("Partitions: %s", partitions)
+
+await consumer.subscribe(["topic"], on_other=unknown_kwarg_subscribe_callback)
diff --git a/python-checks/src/test/resources/checks/beautifulSoupClassList.py b/python-checks/src/test/resources/checks/beautifulSoupClassList.py
new file mode 100644
index 0000000000..8962dd6ec7
--- /dev/null
+++ b/python-checks/src/test/resources/checks/beautifulSoupClassList.py
@@ -0,0 +1,80 @@
+from bs4 import BeautifulSoup
+
+html = "
                test
                "
+soup = BeautifulSoup(html, 'html.parser')
+
+# --- List-returning methods → "Use select()" ---
+
+result = soup.find_all('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+#                             ^^^^^^^^^^^^^^^^^
+result = soup.findAll('div', class_=['A', 'B'])   # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+result = soup.find_all(class_=['A', 'B', 'C'])   # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+result = soup.find_all('div', class_=['A', 'B', 'C'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+#                             ^^^^^^^^^^^^^^^^^^^^^^
+result = soup.findChildren('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+
+result = soup.find_parents('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+result = soup.findParents('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+
+result = soup.find_all_next('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+result = soup.findAllNext('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+
+result = soup.find_next_siblings('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+result = soup.findNextSiblings('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+
+result = soup.find_all_previous('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+result = soup.findAllPrevious('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+
+result = soup.find_previous_siblings('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+result = soup.findPreviousSiblings('div', class_=['A', 'B'])  # Noncompliant {{Use "select()" with a chained CSS class selector instead.}}
+
+# --- Single-result methods → "Use select_one()" ---
+
+result = soup.find('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+result = soup.findChild('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+
+result = soup.find_parent('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+result = soup.findParent('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+
+result = soup.find_next('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+result = soup.findNext('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+
+result = soup.find_next_sibling('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+result = soup.findNextSibling('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+
+result = soup.find_previous('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+result = soup.findPrevious('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+
+result = soup.find_previous_sibling('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+result = soup.findPreviousSibling('div', class_=['A', 'B'])  # Noncompliant {{Use "select_one()" with a chained CSS class selector instead.}}
+
+# Compliant: use CSS selector instead
+result = soup.select('div.A.B')
+result = soup.select_one('div.A.B')
+
+# Compliant: single class string
+result = soup.find_all('div', class_='A')
+result = soup.find('div', class_='A')
+result = soup.find_parent('div', class_='A')
+result = soup.find_next('div', class_='A')
+result = soup.find_next_sibling('div', class_='A')
+result = soup.find_previous('div', class_='A')
+result = soup.find_previous_sibling('div', class_='A')
+
+# Compliant: single-element list (no ambiguity)
+result = soup.find_all('div', class_=['A'])
+result = soup.find('div', class_=['A'])
+
+# Compliant: no class_ argument
+result = soup.find_all('div')
+result = soup.find('div')
+result = soup.find_all('div', other=['A', 'B'])
+
+def not_beautifulsoup(some_obj):
+    # Compliant: not a bs4 object
+    result = some_obj.find_all('div', class_=['A', 'B'])
+    result = some_obj.findAll('div', class_=['A', 'B'])
+    result = some_obj.find('div', class_=['A', 'B'])
+    result = some_obj.findChild('div', class_=['A', 'B'])
+    result = some_obj.find_parent('div', class_=['A', 'B'])
+    result = some_obj.findParent('div', class_=['A', 'B'])
diff --git a/python-checks/src/test/resources/checks/beautifulSoupDeprecatedNames.py b/python-checks/src/test/resources/checks/beautifulSoupDeprecatedNames.py
new file mode 100644
index 0000000000..5d627a6ab4
--- /dev/null
+++ b/python-checks/src/test/resources/checks/beautifulSoupDeprecatedNames.py
@@ -0,0 +1,107 @@
+from bs4 import BeautifulSoup, Tag
+
+html = "Click here"
+soup = BeautifulSoup(html, 'html.parser')
+# Construct a Tag directly so the type inference yields a definite 'bs4.element.Tag' type
+tag = Tag(name='a')
+
+
+# Deprecated method calls on BeautifulSoup
+def deprecated_methods_on_soup():
+    soup.findAll('a')  # Noncompliant {{Replace the deprecated 'findAll()' method with 'find_all()'.}}
+    soup.findChild('a')  # Noncompliant {{Replace the deprecated 'findChild()' method with 'find()'.}}
+    soup.findChildren('a')  # Noncompliant {{Replace the deprecated 'findChildren()' method with 'find_all()'.}}
+    soup.findNext('a')  # Noncompliant {{Replace the deprecated 'findNext()' method with 'find_next()'.}}
+    soup.findAllNext('a')  # Noncompliant {{Replace the deprecated 'findAllNext()' method with 'find_all_next()'.}}
+    soup.findPrevious('a')  # Noncompliant {{Replace the deprecated 'findPrevious()' method with 'find_previous()'.}}
+    soup.findAllPrevious('a')  # Noncompliant {{Replace the deprecated 'findAllPrevious()' method with 'find_all_previous()'.}}
+    soup.findNextSibling('a')  # Noncompliant {{Replace the deprecated 'findNextSibling()' method with 'find_next_sibling()'.}}
+    soup.findNextSiblings('a')  # Noncompliant {{Replace the deprecated 'findNextSiblings()' method with 'find_next_siblings()'.}}
+    soup.findPreviousSibling('a')  # Noncompliant {{Replace the deprecated 'findPreviousSibling()' method with 'find_previous_sibling()'.}}
+    soup.findPreviousSiblings('a')  # Noncompliant {{Replace the deprecated 'findPreviousSiblings()' method with 'find_previous_siblings()'.}}
+    soup.findParent('a')  # Noncompliant {{Replace the deprecated 'findParent()' method with 'find_parent()'.}}
+    soup.findParents('a')  # Noncompliant {{Replace the deprecated 'findParents()' method with 'find_parents()'.}}
+    soup.replaceWith('other')  # Noncompliant {{Replace the deprecated 'replaceWith()' method with 'replace_with()'.}}
+    soup.getText()  # Noncompliant {{Replace the deprecated 'getText()' method with 'get_text()'.}}
+
+
+# Deprecated method calls on Tag (find() returns a Tag, which is also a PageElement)
+def deprecated_methods_on_tag():
+    tag.findAll('b')  # Noncompliant {{Replace the deprecated 'findAll()' method with 'find_all()'.}}
+    tag.findChild('b')  # Noncompliant {{Replace the deprecated 'findChild()' method with 'find()'.}}
+    tag.findNext('b')  # Noncompliant {{Replace the deprecated 'findNext()' method with 'find_next()'.}}
+    tag.getText()  # Noncompliant {{Replace the deprecated 'getText()' method with 'get_text()'.}}
+
+
+# Deprecated attribute access
+def deprecated_attributes():
+    _ = soup.nextSibling  # Noncompliant {{Replace the deprecated 'nextSibling' attribute with 'next_sibling'.}}
+    _ = soup.previousSibling  # Noncompliant {{Replace the deprecated 'previousSibling' attribute with 'previous_sibling'.}}
+    _ = tag.nextSibling  # Noncompliant {{Replace the deprecated 'nextSibling' attribute with 'next_sibling'.}}
+    _ = tag.previousSibling  # Noncompliant {{Replace the deprecated 'previousSibling' attribute with 'previous_sibling'.}}
+
+
+# Deprecated text= keyword argument (on modern method names)
+def deprecated_text_kwarg():
+    soup.find('a', text='Click here')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_all('a', text='Click here')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_next('a', text='x')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_all_next('a', text='x')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_previous('a', text='x')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_all_previous('a', text='x')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_next_sibling('a', text='x')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_next_siblings('a', text='x')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_previous_sibling('a', text='x')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_previous_siblings('a', text='x')  # Noncompliant {{Replace the deprecated 'text' keyword argument with 'string'.}}
+    soup.find_parent('a', text='x')  # Compliant - find_parent does not accept a string= argument
+    soup.find_parents('a', text='x')  # Compliant - find_parents does not accept a string= argument
+
+
+# Deprecated method + deprecated text= argument = two issues on same call
+def deprecated_method_and_text_kwarg():
+    soup.findAll('a', text='Click here')  # Noncompliant {{Replace the deprecated 'findAll()' method with 'find_all()'.}}
+    # Noncompliant@-1 {{Replace the deprecated 'text' keyword argument with 'string'.}}
+
+
+# Compliant: modern method names
+def compliant_methods():
+    soup.find('a')
+    soup.find_all('a')
+    soup.find_next('a')
+    soup.find_all_next('a')
+    soup.find_previous('a')
+    soup.find_all_previous('a')
+    soup.find_next_sibling('a')
+    soup.find_next_siblings('a')
+    soup.find_previous_sibling('a')
+    soup.find_previous_siblings('a')
+    soup.find_parent('a')
+    soup.find_parents('a')
+    soup.replace_with('other')
+    soup.get_text()
+
+
+# Compliant: modern attribute names
+def compliant_attributes():
+    _ = soup.next_sibling
+    _ = soup.previous_sibling
+    _ = tag.next_sibling
+    _ = tag.previous_sibling
+
+
+# Compliant: modern string= keyword
+def compliant_string_kwarg():
+    soup.find('a', string='Click here')
+    soup.find_all('a', string='Click here')
+
+
+# Compliant: not a bs4 object
+def compliant_non_bs4():
+    class FakeElement:
+        def findAll(self):
+            pass
+        nextSibling = None
+
+    obj = FakeElement()
+    obj.findAll()  # Compliant - not a bs4 type
+    _ = obj.nextSibling  # Compliant - not a bs4 type
diff --git a/python-checks/src/test/resources/checks/beautifulSoupNoneCheck.py b/python-checks/src/test/resources/checks/beautifulSoupNoneCheck.py
new file mode 100644
index 0000000000..1786886c6c
--- /dev/null
+++ b/python-checks/src/test/resources/checks/beautifulSoupNoneCheck.py
@@ -0,0 +1,330 @@
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+
+html = "
                Hello
                link"
+
+
+# --- Noncompliant: inline chaining on all 7 search methods ---
+
+def noncompliant_find_attr():
+    soup = BeautifulSoup(html, "html.parser")
+    text = soup.find("p").text  # Noncompliant {{Check if this element exists before accessing it with `.text`.}}
+        #       ^^^^
+
+def noncompliant_find_subscript():
+    soup = BeautifulSoup(html, "html.parser")
+    cls = soup.find("a")["class"]  # Noncompliant {{Check if this element exists before accessing it with `[class]`.}}
+    a = "access"
+    cls = soup.find("a")[a]  # Noncompliant {{Check if this element exists before accessing it with `[]`.}}
+
+
+def noncompliant_select_one_attr():
+    soup = BeautifulSoup(html, "html.parser")
+    text = soup.select_one("p").text  # Noncompliant
+
+
+def noncompliant_find_next_attr():
+    soup = BeautifulSoup(html, "html.parser")
+    text = soup.find_next("p").text  # Noncompliant
+
+
+def noncompliant_find_previous_attr():
+    soup = BeautifulSoup(html, "html.parser")
+    text = soup.find_previous("p").text  # Noncompliant
+
+
+def noncompliant_find_next_sibling_attr():
+    soup = BeautifulSoup(html, "html.parser")
+    text = soup.find_next_sibling("p").text  # Noncompliant
+
+
+def noncompliant_find_previous_sibling_attr():
+    soup = BeautifulSoup(html, "html.parser")
+    text = soup.find_previous_sibling("p").text  # Noncompliant
+
+
+def noncompliant_find_parent_attr():
+    soup = BeautifulSoup(html, "html.parser")
+    text = soup.find_parent("div").text  # Noncompliant
+
+
+# --- Noncompliant: method call on search result ---
+
+def noncompliant_method_call_inline():
+    soup = BeautifulSoup(html, "html.parser")
+    text = soup.find("p").get_text()  # Noncompliant
+
+
+def noncompliant_method_call_variable():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    text = element.get_text()  # Noncompliant
+
+
+# --- Noncompliant: chained BS4 search calls ---
+
+def noncompliant_chained_find():
+    soup = BeautifulSoup(html, "html.parser")
+    text = soup.find("div").find("p").text  # Noncompliant {{Check if this element exists before accessing it with `.find`.}}
+        #       ^^^^
+
+
+def noncompliant_chained_find_no_attr():
+    soup = BeautifulSoup(html, "html.parser")
+    inner = soup.find("div").find("p")  # Noncompliant {{Check if this element exists before accessing it with `.find`.}}
+        #        ^^^^
+
+
+def noncompliant_cond_without_return_stmt(cond):
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if not element:
+       pass 
+    text = element.text  # Noncompliant
+#
+# --- Noncompliant: "is not " is not a None-guard ---
+
+def noncompliant_is_not_non_none(other):
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element is not other:
+        text = element.text  # Noncompliant
+
+
+# --- Noncompliant: variable assignment then unguarded access ---
+
+def noncompliant_variable_attr():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    text = element.text  # Noncompliant
+        #          ^^^^
+
+def noncompliant_variable_subscript():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("a")
+    cls = element["class"]  # Noncompliant
+    #     ^^^^^^^^^^^^^^^^
+
+def noncompliant_variable_select_one():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.select_one("p")
+    text = element.text  # Noncompliant
+
+
+# --- Compliant: guarded with "if element is not None:" ---
+
+def compliant_is_not_none():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element is not None:
+        text = element.text  # Compliant
+        cls = element["class"]  # Compliant
+
+
+# --- Compliant: guarded with "if element:" ---
+
+def compliant_truthiness():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element:
+        text = element.text  # Compliant
+
+
+# --- Compliant: nested if inside a None-guard ---
+
+def compliant_nested_if():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element is not None:
+        if True:
+            text = element.text  # Compliant
+
+
+# --- Compliant: compound "and" condition (guard on left or right) ---
+
+def compliant_and_condition_guard_left():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element is not None and True:
+        text = element.text  # Compliant
+
+
+def compliant_and_condition_guard_right():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if True and element is not None:
+        text = element.text  # Compliant
+
+
+# --- Compliant: guarded with "if element != None:" ---
+
+def compliant_not_equal_none():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element != None:
+        text = element.text  # Compliant
+
+
+# --- Compliant: subscription as assignment target (write, not read) ---
+
+def compliant_subscription_assignment_target():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element:
+        element["class"] = "active"  # Compliant
+
+
+# --- Compliant: early-return guard with "if element == None:" ---
+
+def compliant_early_return_equal_none():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element == None:
+        return
+    text = element.text  # Compliant
+
+
+def compliant_early_return_none_equal():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if None == element:
+        return
+    text = element.text  # Compliant
+
+
+def compliant_early_return_none_is():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if None is element:
+        return
+    text = element.text  # Compliant
+
+
+# --- Compliant: early-return guard ---
+
+def compliant_early_return_is_none():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element is None:
+        return
+    text = element.text  # Compliant
+
+
+def compliant_early_return_not():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if not element:
+        return
+    text = element.text  # Compliant
+
+
+# --- Compliant: "None != element" guard ---
+
+def compliant_none_not_equal():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if None != element:
+        text = element.text  # Compliant
+
+
+# --- Noncompliant: inverted guard (early-return on is-not-None leaves only None path) ---
+
+def noncompliant_early_return_is_not_none():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    if element is not None:
+        return
+    text = element.text  # Noncompliant
+
+
+# --- Noncompliant: assert element is None (asserts None, then accesses) ---
+
+def noncompliant_assert_is_none():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    assert element is None
+    text = element.text  # Noncompliant
+
+
+# --- Noncompliant: dynamic subscript ([] fallback description) ---
+
+def noncompliant_dynamic_subscript():
+    soup = BeautifulSoup(html, "html.parser")
+    key = "class"
+    cls = soup.find("a")[key]  # Noncompliant {{Check if this element exists before accessing it with `[]`.}}
+
+
+# --- Compliant: unresolved name (valuesAtLocation returns empty) ---
+
+def compliant_unresolved_name(element):
+    # element is a parameter — valuesAtLocation returns empty, no issue raised
+    text = element.text  # Compliant
+
+
+# --- Compliant: assert guard ---
+
+def compliant_assert_truthy():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    assert element
+    text = element.text  # Compliant
+
+
+def compliant_assert_is_not_none():
+    soup = BeautifulSoup(html, "html.parser")
+    element = soup.find("p")
+    assert element is not None
+    text = element.text  # Compliant
+
+
+# --- Compliant: inline chaining inside try/except catching AttributeError ---
+
+def compliant_try_except_attribute_error():
+    soup = BeautifulSoup(html, "html.parser")
+    try:
+        text = soup.find("p").text  # Compliant
+    except AttributeError:
+        pass
+
+
+def noncompliant_try_except_exception():
+    soup = BeautifulSoup(html, "html.parser")
+    try:
+        text = soup.find("p").text  # Noncompliant
+    except Exception:
+        pass
+
+
+def noncompliant_try_except_bare():
+    soup = BeautifulSoup(html, "html.parser")
+    try:
+        text = soup.find("p").text  # Noncompliant
+    except:
+        pass
+
+
+def compliant_try_except_tuple():
+    soup = BeautifulSoup(html, "html.parser")
+    try:
+        text = soup.find("p").text  # Compliant
+    except (AttributeError, TypeError):
+        pass
+
+
+# --- Noncompliant: inline chaining inside try/except catching unrelated exception ---
+
+def noncompliant_try_except_unrelated():
+    soup = BeautifulSoup(html, "html.parser")
+    try:
+        text = soup.find("p").text  # Noncompliant
+    except ValueError:
+        pass
+
+
+# --- Compliant: non-BS4 object ---
+
+def compliant_non_bs4():
+    d = {"key": "value"}
+    val = d["key"]  # Compliant
+    text = d.get("key")  # Compliant
+
diff --git a/python-checks/src/test/resources/checks/beautifulSoupParser.py b/python-checks/src/test/resources/checks/beautifulSoupParser.py
new file mode 100644
index 0000000000..5282395003
--- /dev/null
+++ b/python-checks/src/test/resources/checks/beautifulSoupParser.py
@@ -0,0 +1,31 @@
+from bs4 import BeautifulSoup
+
+html = "
                test
                "
+
+soup = BeautifulSoup(html)  # Noncompliant {{Specify the parser to use for "BeautifulSoup".}}
+#      ^^^^^^^^^^^^^
+soup = BeautifulSoup()  # Noncompliant
+#      ^^^^^^^^^^^^^
+soup = BeautifulSoup(html, None)
+soup = BeautifulSoup(html, features=None)
+
+# Compliant: features specified as second positional arg
+soup = BeautifulSoup(html, 'html.parser')
+soup = BeautifulSoup(html, 'lxml')
+soup = BeautifulSoup(html, 'html5lib')
+
+# Compliant: features specified as keyword argument
+soup = BeautifulSoup(html, features='html.parser')
+soup = BeautifulSoup(features='html.parser', markup=html)
+
+# Compliant: builder specified (alternative way to pin the parser)
+from bs4.builder import HTMLParserTreeBuilder
+soup = BeautifulSoup(html, builder=None)
+soup = BeautifulSoup(html, builder=HTMLParserTreeBuilder())
+soup = BeautifulSoup(html, None, HTMLParserTreeBuilder())  # builder as 3rd positional
+
+# Compliant: not a bs4 BeautifulSoup
+class BeautifulSoup:
+    def __init__(self, markup): pass
+
+soup = BeautifulSoup(html)  # Not bs4 - no issue
diff --git a/python-checks/src/test/resources/checks/beautifulSoupRawHtmlInsertion.py b/python-checks/src/test/resources/checks/beautifulSoupRawHtmlInsertion.py
new file mode 100644
index 0000000000..75a8f14c19
--- /dev/null
+++ b/python-checks/src/test/resources/checks/beautifulSoupRawHtmlInsertion.py
@@ -0,0 +1,41 @@
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+
+soup = BeautifulSoup('', 'html.parser')
+
+soup.insert(0, '
                ')  # Noncompliant {{Use "new_tag()" instead of inserting raw HTML strings.}}
+#    ^^^^^^
+soup.append('
                some text
                ')                  # Noncompliant {{Use "new_tag()" instead of inserting raw HTML strings.}}
+tag = soup.new_tag('section')
+tag.insert(0, '')         # Noncompliant {{Use "new_tag()" instead of inserting raw HTML strings.}}
+tag.append('bold')                        # Noncompliant {{Use "new_tag()" instead of inserting raw HTML strings.}}
+tag.extend('
              • item
                • ')                      # Noncompliant {{Use "new_tag()" instead of inserting raw HTML strings.}}
+soup.extend(tags='
              • item
                • ') # Noncompliant
+# Compliant: plain text strings — idiomatic NavigableString insertion
+soup.append("Hello world")   # Compliant - no markup
+tag.insert(0, "some text")   # Compliant - no markup
+
+# Variable holding an HTML string literal — value is traced back to the literal
+html_fragment = '
                '
+tag.insert(0, html_fragment)   # Noncompliant {{Use "new_tag()" instead of inserting raw HTML strings.}}
+tag.append(html_fragment)      # Noncompliant {{Use "new_tag()" instead of inserting raw HTML strings.}}
+
+# Compliant: using new_tag() to create proper element objects
+new_tag = soup.new_tag('div', id='file_history')
+soup.insert(0, new_tag)   # Compliant
+soup.append(new_tag)      # Compliant
+
+# Compliant: not a string
+soup.insert(0, 42)        # Compliant
+soup.append(None)         # Compliant
+
+# Compliant: extend with a list
+soup.extend([new_tag])    # Compliant
+soup.extend(tags=['
              • item
                • '])
+
+soup.append("<= 3") # Compliant not the shape of a tag
+
+# Compliant: called on a non-Tag type
+my_list = [1, 2, 3]
+my_list.insert(0, '
                ')   # Compliant - not a Tag
+my_list.append('
                ')        # Compliant - not a Tag
diff --git a/python-checks/src/test/resources/checks/booleanCheckNotInverted.py b/python-checks/src/test/resources/checks/booleanCheckNotInverted.py
index bf4899ca94..3eca4a5d59 100644
--- a/python-checks/src/test/resources/checks/booleanCheckNotInverted.py
+++ b/python-checks/src/test/resources/checks/booleanCheckNotInverted.py
@@ -1,4 +1,4 @@
-from typing import Set, Any
+from typing import Set, FrozenSet, Any
 
 a = 1
 b = 2
@@ -126,3 +126,37 @@ def check_conditional_set_comparison(a, cond):
     # FP: We don't know whether b is of type set in this case. An issue shouldn't be raised.
     if not (a <= b): # Noncompliant
         ...
+
+
+def check_frozenset_as_declared_type(a: frozenset[str], b: frozenset[str]) -> None:
+    if not (a <= b): # OK: comparing two frozensets.
+        ...
+    if not (a == b): # Noncompliant
+        ...
+    if not (a < b): # OK: comparing two frozensets.
+        ...
+    if not (a > b): # OK: comparing two frozensets.
+        ...
+    if not (a >= b): # OK: comparing two frozensets.
+        ...
+
+
+class CustomFrozenSet(frozenset):
+    ...
+
+
+def check_frozenset_as_custom_subclass(a: CustomFrozenSet, b: CustomFrozenSet) -> None:
+    if not (a <= b): # OK
+        ...
+
+
+def check_frozenset_literal(a, b) -> None:
+    x: frozenset[int] = frozenset({1, 2})
+    y: frozenset[int] = frozenset({1, 2, 3})
+    if not x <= y: # OK: comparing two frozensets.
+        ...
+
+
+def check_frozenset_typing_annotation(a: FrozenSet[str], b: FrozenSet[str]) -> None:
+    if not (a <= b): # OK: comparing two frozensets with typing.FrozenSet.
+        ...
diff --git a/python-checks/src/test/resources/checks/booleanExpressionInExcept.py b/python-checks/src/test/resources/checks/booleanExpressionInExcept.py
index 01aef04e20..e5774b9a46 100644
--- a/python-checks/src/test/resources/checks/booleanExpressionInExcept.py
+++ b/python-checks/src/test/resources/checks/booleanExpressionInExcept.py
@@ -29,3 +29,60 @@
     pass
 except* (ValueError):
     pass
+
+# === `|` bitwise OR ===
+try:
+    foo()
+except ValueError | TypeError:  # Noncompliant
+    pass
+except ValueError | TypeError as e:  # Noncompliant
+    pass
+except (ValueError | TypeError):  # Noncompliant
+    pass
+except ConnectionError | TimeoutError | OSError:  # Noncompliant
+    pass
+
+# === `&` bitwise AND ===
+try:
+    foo()
+except ValueError & TypeError:  # Noncompliant
+    pass
+except ValueError & TypeError as e:  # Noncompliant
+    pass
+except (ValueError & TypeError):  # Noncompliant
+    pass
+
+# === `except*` variants for bitwise operators ===
+try:
+    foo()
+except* ValueError | TypeError:  # Noncompliant
+    pass
+except* ValueError & TypeError:  # Noncompliant
+    pass
+
+# === Mixed: one valid handler, one with a bitwise operator ===
+try:
+    foo()
+except TypeError:
+    pass
+except ValueError | KeyError:  # Noncompliant
+    pass
+
+try:
+    foo()
+except* TypeError:
+    pass
+except* ValueError | KeyError:  # Noncompliant
+    pass
+
+# === Arithmetic operators are out of scope (e.g. tuple + tuple is valid Python) ===
+connection_errors = (ConnectionError, OSError)
+channel_errors = (KeyError,)
+try:
+    foo()
+except connection_errors + channel_errors as exc:
+    pass
+except connection_errors + channel_errors:
+    pass
+except (connection_errors + channel_errors):
+    pass
diff --git a/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveCfnMethodCheck.py b/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveCfnMethodCheck.py
index 835435c65e..8e9cb28b74 100644
--- a/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveCfnMethodCheck.py
+++ b/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveCfnMethodCheck.py
@@ -5,9 +5,14 @@ def __init__(self, auth_from_argument):
         apigateway.CfnMethod(
             self,
             "no-auth",
-            authorization_type="NONE"  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+            authorization_type="NONE"  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
+        apigateway.CfnMethod(
+            self,
+            "no-auth-omit"
+        )  # Compliant - omission no longer flagged
+
         apigateway.CfnMethod(
             self,
             "auth",
@@ -32,17 +37,12 @@ def __init__(self, auth_from_argument):
             authorization_type="COGNITO_USER_POOLS"  # Compliant
         )
 
-        apigateway.CfnMethod(   # NonCompliant{{Omitting "authorization_type" disables authentication. Make sure it is safe here.}}
-            self,
-            "no-auth"
-        )
-
         auth_type_none = "NONE"
 #       ^^^^^^^^^^^^^^^^^^^^^^^>
         apigateway.CfnMethod(
             self,
             "no-auth",
-            authorization_type=auth_type_none  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+            authorization_type=auth_type_none  # NonCompliant{{Ensure this API route requires authentication.}}
 #           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         )
 
diff --git a/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveCfnRouteCheck.py b/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveCfnRouteCheck.py
index b990bac813..0dac9b7928 100644
--- a/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveCfnRouteCheck.py
+++ b/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveCfnRouteCheck.py
@@ -3,16 +3,16 @@
 class PublicApiIsSecuritySensitiveCfnRouteCheck:
     def __init__(self, auth_from_argument):
 
-        apigateway.CfnRoute(  # NonCompliant{{Omitting "authorization_type" disables authentication. Make sure it is safe here.}}
+        apigateway.CfnRoute(
             self,
-            "default-no-auth"
+            "no-auth",
+            authorization_type="NONE"  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
         apigateway.CfnRoute(
             self,
-            "no-auth",
-            authorization_type="NONE"  # NonCompliant{{Make sure that creating public APIs is safe here.}}
-        )
+            "default-no-auth"
+        )  # Compliant - omission no longer flagged
 
         apigateway.CfnRoute(
             self,
@@ -31,7 +31,7 @@ def __init__(self, auth_from_argument):
         apigateway.CfnRoute(
             self,
             "no-auth",
-            authorization_type=auth_type_none  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+            authorization_type=auth_type_none  # NonCompliant{{Ensure this API route requires authentication.}}
 #           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         )
 
diff --git a/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveRestApiCheck.py b/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveRestApiCheck.py
index 64249e7f60..47a4314bf0 100644
--- a/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveRestApiCheck.py
+++ b/python-checks/src/test/resources/checks/cdk/publicApiIsSecuritySensitiveRestApiCheck.py
@@ -1,153 +1,466 @@
-import aws_cdk.aws_apigateway as apigateway
+import aws_cdk.aws_apigateway as apigw
 
 
-class PublicApiIsSecuritySensitiveRestApiCheck:
-    def __init__(self, auth_from_argument):
-        api = apigateway.RestApi(
-            self,
-            "RestApi"
+class GateOne:
+    def __init__(self):
+        api = apigw.RestApi(self, "MyApi")
+
+        # Gate 1: state-changing methods → NonCompliant
+        api.root.add_resource("users").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+        api.root.add_resource("items").add_method(
+            "PUT",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+        api.root.add_resource("items").add_method(
+            "DELETE",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+        api.root.add_resource("items").add_method(
+            "PATCH",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+        api.root.add_resource("items").add_method(
+            "ANY",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
-        test = api.root.add_resource("test")
-        test.add_method(
+        # Gate 1: safe (read-only) methods → Compliant
+        api.root.add_resource("users").add_method(
             "GET",
-            authorization_type=apigateway.AuthorizationType.NONE  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - GET is not state-changing
+        )
+        api.root.add_resource("users").add_method(
+            "HEAD",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - HEAD is not state-changing
+        )
+        api.root.add_resource("users").add_method(
+            "OPTIONS",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - OPTIONS is not state-changing
         )
 
-        test.add_method(
+        # Non-NONE authorization → Compliant
+        api.root.add_resource("users").add_method(
             "POST",
-            authorization_type=apigateway.AuthorizationType.IAM  # Compliant
+            authorization_type=apigw.AuthorizationType.IAM  # Compliant
+        )
+        api.root.add_resource("users").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.COGNITO  # Compliant
         )
 
-        auth_type_none = apigateway.AuthorizationType.NONE
-#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^>
-        test.add_method(
-            "GET",
-            authorization_type=auth_type_none  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+        # NONE via variable → NonCompliant (secondary location on assignment)
+        auth_type_none = apigw.AuthorizationType.NONE
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^>
+        api.root.add_resource("users").add_method(
+            "POST",
+            authorization_type=auth_type_none  # NonCompliant{{Ensure this API route requires authentication.}}
 #           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         )
 
-        auth_type_cognito = apigateway.AuthorizationType.COGNITO
-        test.add_method(
+        # authorization_type from unknown external → Compliant
+        api.root.add_resource("users").add_method(
+            "POST",
+            authorization_type=auth_from_argument  # Compliant - value comes from outside
+        )
+
+        # HTTP method from variable → Compliant (cannot prove method statically)
+        api.root.add_resource("users").add_method(
+            get_method(),
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - method not statically provable
+        )
+
+        # Omitting authorization_type entirely → Compliant (omission is not flagged)
+        api.root.add_resource("users").add_method("POST")  # Compliant - omission not flagged
+
+
+class Stage2Exclusion:
+    def __init__(self):
+        api = apigw.RestApi(self, "MyApi")
+
+        # Stage 2: known-public paths → Compliant even with state-changing methods
+        api.root.add_resource("login").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("signup").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("register").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("healthcheck").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("status").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("token").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("callback").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("jwks").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("well-known").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource(".well-known").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - leading dot normalized
+        )
+        api.root.add_resource("authenticate").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("forgot-password").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("health-check").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
+        )
+        api.root.add_resource("public-keys").add_method(
             "GET",
-            authorization_type=auth_type_cognito
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - public endpoint
         )
 
-        test_child = test.add_resource("testchild")
 
-        test_child.parent_resource.add_method(
-            "HEAD",
-            authorization_type=apigateway.AuthorizationType.NONE  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+class GateTwo:
+    def __init__(self):
+        api = apigw.RestApi(self, "MyApi")
+
+        # Gate 2: exact sensitive segment + GET → NonCompliant
+        api.root.add_resource("admin").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+        api.root.add_resource("management").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+        api.root.add_resource("internal").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
-        test.get_resource("testchild").add_method(
-            "PATCH",
-            authorization_type=apigateway.AuthorizationType.NONE  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+        # Gate 2: compound names are NOT exact matches → Compliant
+        api.root.add_resource("admin-portal").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - not an exact segment match
+        )
+        api.root.add_resource("internal-api").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - not an exact segment match
+        )
+        api.root.add_resource("management-ui").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - not an exact segment match
         )
 
-        test.api.root.add_method(  # NonCompliant{{Omitting "authorization_type" disables authentication. Make sure it is safe here.}}
-            "DELETE"
+        # Gate 2 via variable assignment (ExpressionFlow resolves the receiver)
+        admin_res = api.root.add_resource("admin")
+        admin_res.add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
-        test.api.root.add_method(
-            "DELETE",
-            authorization_type=auth_from_argument   # Compliant, value comes from the outside
+        # Stage 2 exclusion takes priority over Gate 2 via variable assignment
+        login_res = api.root.add_resource("login")
+        login_res.add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - Stage 2 exclusion
         )
 
-        test.api.root.add_method(
-            "DELETE",
-            authorization_type=unknown   # Compliant, value is unknown
+        # Neutral name with GET → no gate fires → Compliant
+        api.root.add_resource("reports").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - neutral name, safe method
         )
 
+        # Case-insensitive path matching
+        api.root.add_resource("Login").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - case-insensitive Stage 2 exclusion
+        )
+        api.root.add_resource("Admin").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
 
-class PublicApiIsSecuritySensitiveRestApiSecureConstructorCheck:
-    def __init__(self, auth_from_argument):
-        api = apigateway.RestApi(
-            self,
-            "RestApiDefault",
-            default_method_options={"authorization_type": apigateway.AuthorizationType.IAM}
+        # Qualifier is a call but not add_resource → path unresolvable → no Gate 2 → Compliant
+        api.root.get_resource("admin").add_method(
+            "GET",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - receiver not add_resource, path unknown
         )
 
-        test = api.root.add_resource("test")
-        test.add_method("GET")  # Compliant; secure default
-        test.add_method(
+        # Variable assigned to non-add_resource call → path unresolvable → no Gate 2 → Compliant
+        some_res = api.root.get_resource("admin")
+        some_res.add_method(
             "GET",
-            authorization_type=apigateway.AuthorizationType.NONE  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - receiver not add_resource, path unknown
+        )
+
+
+class PrivateEndpoint:
+    def __init__(self):
+        # Compliant: PRIVATE endpoint — VPC-only API, all methods suppressed
+        private_api = apigw.RestApi(self, "PrivateApi",
+            endpoint_configuration=apigw.EndpointConfiguration(
+                types=[apigw.EndpointType.PRIVATE]
+            )
+        )
+        private_api.root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - VPC-only API
         )
-        test.api.root.add_method(
+        private_api.root.add_resource("data").add_method(
             "DELETE",
-            authorization_type=apigateway.AuthorizationType.NONE  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - VPC-only API
         )
-        test.api.root.add_method(  # Compliant; secure default
-            "DELETE"
+
+        # Compliant: PRIVATE with nested add_resource
+        private_api.root.add_resource("a").add_resource("b").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - VPC-only API
         )
-        test_child = test.add_resource("test_child")
-        test_child.parent_resource.add_method("HEAD")   # Compliant; secure default
-        test_child.parent_resource.add_method(
-            "HEAD",
-            authorization_type=apigateway.AuthorizationType.NONE  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+
+        # Compliant: PRIVATE via variable resource
+        nested = private_api.root.add_resource("nested")
+        nested.add_method(
+            "DELETE",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - VPC-only API
         )
-        test_child.parent_resource.add_method(
-            "HEAD",
-            authorization_type=auth_from_argument   # Compliant, value comes from the outside
+
+        # Public (EDGE) endpoint — no suppression, still raises
+        public_api = apigw.RestApi(self, "PublicApi")
+        public_api.root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
-class PublicApiIsSecuritySensitiveRestApiSecureAddResourceCallCheck:
-    def __init__(self, auth_from_argument):
-        api = apigateway.RestApi(
-            self,
-            "RestApiDefault"
+        # REGIONAL endpoint is not PRIVATE — still raises
+        regional_api = apigw.RestApi(self, "RegionalApi",
+            endpoint_configuration=apigw.EndpointConfiguration(
+                types=[apigw.EndpointType.REGIONAL]
+            )
+        )
+        regional_api.root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
-        opts = apigateway.MethodOptions(
-            authorization_type=apigateway.AuthorizationType.IAM
+
+class NestedResourceViaVariable:
+    def __init__(self):
+        api = apigw.RestApi(self, "MyApi")
+
+        # Variable holding intermediate add_resource, then chained add_resource on it
+        # Exercises the resolveRestApi NAME→assigned-CALL_EXPR path.
+        base = api.root.add_resource("base")
+        base.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
-        test = api.root.add_resource(
-            "test",
-            default_method_options=opts
+        # Same shape, Stage 2 exclusion applies through the resolved chain.
+        base2 = api.root.add_resource("base2")
+        base2.add_resource("login").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - safe path
         )
-        test.add_method(  # Compliant because of default_method_options
-            "GET"
+
+        # PRIVATE suppression still applies via this nested variable chain.
+        private_api = apigw.RestApi(self, "PrivateApi2",
+            endpoint_configuration=apigw.EndpointConfiguration(
+                types=[apigw.EndpointType.PRIVATE]
+            )
         )
-        test.add_method(
-            "GET",
-            authorization_type=auth_from_argument   # Compliant, value comes from the outside
+        nested_base = private_api.root.add_resource("nested_base")
+        nested_base.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - VPC-only API
         )
-        test.add_method(
-            "GET",
-            authorization_type=unknown   # Compliant, value is unknown
+
+
+class AddMethodOnRootDirectly:
+    def __init__(self):
+        api = apigw.RestApi(self, "MyApi")
+
+        # add_method called directly on api.root — qualifier of add_method's callee
+        # is a QualifiedExpression (api.root), so resolveToAddResourceCall returns null.
+        # Path resolution yields empty; Gate 1 still fires for state-changing methods.
+        api.root.add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
-        test.add_method(
+
+        # Non state-changing method on api.root → no Gate 1, no path → Compliant.
+        api.root.add_method(
             "GET",
-            authorization_type=apigateway.AuthorizationType.NONE  # NonCompliant{{Make sure that creating public APIs is safe here.}}
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - no resource path resolved
+        )
+
+
+class HttpMethodMissing:
+    def __init__(self):
+        api = apigw.RestApi(self, "MyApi")
+
+        # Authorization is NONE but http_method argument is absent entirely.
+        # Gate 1 cannot fire; path "users" is neutral → Compliant.
+        api.root.add_resource("users").add_method(
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - http_method omitted
+        )
+
+        # No http_method but sensitive path → Gate 2 fires.
+        api.root.add_resource("admin").add_method(
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+
+
+class ApiReassigned:
+    def __init__(self):
+        # api is reassigned, so singleAssignedValue returns null.
+        # resolveToRestApiCall stays at the Name expression (not a CALL_EXPR)
+        # and returns empty — PRIVATE suppression cannot be confirmed.
+        api = apigw.RestApi(self, "ApiA")
+        api = apigw.RestApi(self, "ApiB")
+        api.root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+
+
+class ApiInstantiatedInline:
+    def __init__(self):
+        # apigw.RestApi(...) used inline, no variable.
+        # qe.qualifier() in resolveRestApi is a CALL_EXPR (not a Name),
+        # exercising the non-NAME branch of resolveToRestApiCall.
+        apigw.RestApi(self, "InlineApi").root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+
+
+class EndpointConfigurationViaVariable:
+    def __init__(self):
+        # endpoint_configuration argument is a Name (config), not a direct
+        # EndpointConfiguration(...) call. The predicate's CALL_EXPR check
+        # fails on the Name expression in the flow.
+        config_name = "regional"
+        api = apigw.RestApi(self, "VarApi", endpoint_configuration=config_name)
+        api.root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+
+        # endpoint_configuration is a CALL_EXPR but NOT EndpointConfiguration.
+        api2 = apigw.RestApi(self, "WrongCallApi", endpoint_configuration=apigw.AuthorizationType.NONE)
+        api2.root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+
+
+class EndpointConfigurationWithoutTypes:
+    def __init__(self):
+        # EndpointConfiguration without "types" argument → cascade short-circuits.
+        api = apigw.RestApi(self, "NoTypesApi",
+            endpoint_configuration=apigw.EndpointConfiguration()
+        )
+        api.root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+
+
+class NonPathLiteralResource:
+    def __init__(self):
+        api = apigw.RestApi(self, "MyApi")
+
+        # path_part argument is a dynamic expression (not a string literal) — path stays empty.
+        api.root.add_resource(get_dynamic_path()).add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
-        test.add_method(
+        api.root.add_resource(get_dynamic_path()).add_method(
             "GET",
-            authorization_type=apigateway.AuthorizationType.IAM  # Compliant
+            authorization_type=apigw.AuthorizationType.NONE  # Compliant - path unresolvable, safe method
         )
 
-class PublicApiIsSecuritySensitiveRestApiUnsecureConstructorDictionary:
+
+def get_dynamic_path():
+    return external_value
+
+
+class ResourceReassigned:
     def __init__(self):
-        api = apigateway.RestApi(
-            self,
-            "RestApiDefault",
-            default_method_options={"authorization_type": apigateway.AuthorizationType.NONE}
+        api = apigw.RestApi(self, "MyApi")
+
+        # Variable holding a Resource is reassigned — singleAssignedValue returns null
+        # for the qualifier of add_method, hitting the assigned==null branch of
+        # resolveToAddResourceCall. Gate 1 still raises for state-changing methods.
+        res = api.root.add_resource("first")
+        res = api.root.add_resource("admin")
+        res.add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
+
+        # Variable reassigned, then used as receiver of a nested add_resource —
+        # exercises the assigned==null branch within resolveRestApi's NAME branch.
+        nested_var = api.root.add_resource("a")
+        nested_var = api.root.add_resource("b")
+        nested_var.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
-        test = api.root.add_resource("test")
-        test.add_method("GET")  # NonCompliant{{Omitting "authorization_type" disables authentication. Make sure it is safe here.}}
 
-class PublicApiIsSecuritySensitiveRestApiUnsecureConstructorMethodOptions:
+class EndpointConfigurationFromCall:
     def __init__(self):
-        opts = apigateway.MethodOptions(
-            authorization_type=apigateway.AuthorizationType.NONE
+        # endpoint_configuration is a CALL_EXPR but its FQN is not
+        # apigw.EndpointConfiguration — the predicate returns false and suppression is skipped.
+        api = apigw.RestApi(self, "FromCallApi", endpoint_configuration=build_some_config())
+        api.root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
-        api = apigateway.RestApi(
-            self,
-            "RestApiDefault",
-            default_method_options=opts
+
+
+def build_some_config():
+    return None
+
+
+class ApiAndResourceAliasedViaName:
+    def __init__(self):
+        # api is assigned to another Name (alias), not directly to a CALL_EXPR.
+        # resolveToRestApiCall sees assigned != null but resolved.is(CALL_EXPR) is false.
+        real_api = apigw.RestApi(self, "RealApi")
+        api = real_api
+        api.root.add_resource("admin").add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
         )
 
-        test = api.root.add_resource("test")
-        test.add_method("GET")  # NonCompliant{{Omitting "authorization_type" disables authentication. Make sure it is safe here.}}
+        # Resource alias: variable holding a Resource is reassigned via another Name.
+        # In resolveToAddResourceCall, assigned != null but is not a CALL_EXPR.
+        real_res = real_api.root.add_resource("inner")
+        res_alias = real_res
+        res_alias.add_method(
+            "POST",
+            authorization_type=apigw.AuthorizationType.NONE  # NonCompliant{{Ensure this API route requires authentication.}}
+        )
diff --git a/python-checks/src/test/resources/checks/cdk/s3BucketBlockPublicAccessCheck.py b/python-checks/src/test/resources/checks/cdk/s3BucketBlockPublicAccessCheck.py
index 8746d59f11..ef805b8f34 100644
--- a/python-checks/src/test/resources/checks/cdk/s3BucketBlockPublicAccessCheck.py
+++ b/python-checks/src/test/resources/checks/cdk/s3BucketBlockPublicAccessCheck.py
@@ -7,23 +7,19 @@ class NonCompliantStack(Stack):
     def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
         super().__init__(scope, construct_id, **kwargs)
 
-        # NonCompliant@+1 {{No Public Access Block configuration prevents public ACL/policies to be set on this S3 bucket. Make sure it is safe here.}}
-        bucket = s3.Bucket(self, "PublicAccessIsNotBlockedByDefault")
-        #        ^^^^^^^^^
+        # NonCompliant@+2 {{Using BLOCK_ACLS_ONLY allows public access via bucket policies.}}
+        bucket = s3.Bucket(self, "PublicAccessOnlyBlockAclsOnly",
+                           block_public_access=s3.BlockPublicAccess.BLOCK_ACLS_ONLY)
 
-        # NonCompliant@+2 {{Make sure allowing public ACL/policies to be set is safe here.}}
-        bucket = s3.Bucket(self, "PublicAccessOnlyBlockAcls",
-                           block_public_access=s3.BlockPublicAccess.BLOCK_ACLS)
-
-        public_access_only_block_acls_by_reference = s3.BlockPublicAccess.BLOCK_ACLS
-    #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^> {{Propagated setting.}}
-        bucket = s3.Bucket(self, "PublicAccessOnlyBlockAclsByReference",
-                           block_public_access=public_access_only_block_acls_by_reference)  # NonCompliant {{Make sure allowing public ACL/policies to be set is safe here.}}
-    #                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        public_access_only_block_acls_only_by_reference = s3.BlockPublicAccess.BLOCK_ACLS_ONLY
+    #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^> {{Propagated setting.}}
+        bucket = s3.Bucket(self, "PublicAccessOnlyBlockAclsOnlyByReference",
+                           block_public_access=public_access_only_block_acls_only_by_reference)  # NonCompliant {{Using BLOCK_ACLS_ONLY allows public access via bucket policies.}}
+    #                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         bucket = s3.Bucket(self, "SingleUnblockPublicAccesses",
                            block_public_access=s3.BlockPublicAccess(
-                               block_public_acls=False,  # NonCompliant {{Make sure allowing public ACL/policies to be set is safe here.}}
+                               block_public_acls=False,  # NonCompliant {{Disabling public access block settings allows public ACL/policies to be set on this S3 bucket.}}
                            #   ^^^^^^^^^^^^^^^^^^^^^^^
                                ignore_public_acls=True,
                                block_public_policy=True,
@@ -31,16 +27,16 @@ def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
 
         bucket = s3.Bucket(self, "MultipleUnblockPublicAccesses",
                            block_public_access=s3.BlockPublicAccess(
-                               block_public_acls=False,  # NonCompliant {{Make sure allowing public ACL/policies to be set is safe here.}}
+                               block_public_acls=False,  # NonCompliant {{Disabling public access block settings allows public ACL/policies to be set on this S3 bucket.}}
                            #   ^^^^^^^^^^^^^^^^^^^^^^^
                                ignore_public_acls=True,
-                               block_public_policy=False,  # NonCompliant {{Make sure allowing public ACL/policies to be set is safe here.}}
+                               block_public_policy=False,  # NonCompliant {{Disabling public access block settings allows public ACL/policies to be set on this S3 bucket.}}
                            #   ^^^^^^^^^^^^^^^^^^^^^^^^^
                                restrict_public_buckets=True))
 
         referenced_unblock_public_accesses = s3.BlockPublicAccess(
             block_public_acls=True,
-            ignore_public_acls=False,  # NonCompliant {{Make sure allowing public ACL/policies to be set is safe here.}}
+            ignore_public_acls=False,  # NonCompliant {{Disabling public access block settings allows public ACL/policies to be set on this S3 bucket.}}
             block_public_policy=True,
             restrict_public_buckets=True)
 
@@ -51,7 +47,7 @@ def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
     #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^> {{Propagated setting.}}
         bucket = s3.Bucket(self, "ReferencedValueUnblockPublicAccesses",
                            block_public_access=s3.BlockPublicAccess(
-                               block_public_acls=referenced_value_unblock_public_accesses,  # NonCompliant {{Make sure allowing public ACL/policies to be set is safe here.}}
+                               block_public_acls=referenced_value_unblock_public_accesses,  # NonCompliant {{Disabling public access block settings allows public ACL/policies to be set on this S3 bucket.}}
                            #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                                ignore_public_acls=True,
                                block_public_policy=True,
@@ -62,9 +58,14 @@ class CompliantStack(Stack):
     def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
         super().__init__(scope, construct_id, **kwargs)
 
+        bucket = s3.Bucket(self, "PublicAccessIsNotBlockedByDefault")
+
         bucket = s3.Bucket(self, "PublicAccessOnlyBlockAll",
                            block_public_access=s3.BlockPublicAccess.BLOCK_ALL)
 
+        bucket = s3.Bucket(self, "PublicAccessOnlyBlockAcls",
+                           block_public_access=s3.BlockPublicAccess.BLOCK_ACLS)
+
         bucket = s3.Bucket(self, "AllBlockPublicAccesses",
                            block_public_access=s3.BlockPublicAccess(
                                block_public_acls=True,
diff --git a/python-checks/src/test/resources/checks/cdk/s3BucketServerEncryption.py b/python-checks/src/test/resources/checks/cdk/s3BucketServerEncryption.py
deleted file mode 100644
index 1dab93fdde..0000000000
--- a/python-checks/src/test/resources/checks/cdk/s3BucketServerEncryption.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from aws_cdk import aws_s3 as s3
-
-bucket = s3.Bucket(self,"MyUnencryptedBucket") # NonCompliant {{Omitting 'encryption' disables server-side encryption. Make sure it is safe here.}}
-#        ^^^^^^^^^
-
-bucket = s3.Bucket(self,"MyUnencryptedBucket", encryption=s3.BucketEncryption.UNENCRYPTED) # NonCompliant {{Objects in the bucket are not encrypted. Make sure it is safe here.}}
-#                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-bucket = s3.Bucket(self,"MyEncryptedBucket",
-                   encryption=s3.BucketEncryption.KMS_MANAGED      # Compliant
-                   )
-bucket = s3.Bucket(self,"MyEncryptedBucket",
-                   encryption=s3.BucketEncryption.S3_MANAGED          # Compliant
-                   )
-bucket = s3.Bucket(self,"MyEncryptedBucket",
-                   encryption=s3.BucketEncryption.KMS          # Compliant
-                   )
-bucket = s3.Bucket(self,"MyEncryptedBucket",
-                   encryption_key=my_encryption_key                 # Compliant
-                   )
-
-bucket = s3.Bucket(self,"MyUnencryptedBucket",
-                   encryption=s3.BucketEncryption.UNENCRYPTED, # NonCompliant {{Objects in the bucket are not encrypted. Make sure it is safe here.}}
-#                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-                   encryption_key=my_encryption_key
-)
-
-type_KMS = s3.BucketEncryption.KMS
-bucket = s3.Bucket(self,"MyEncryptedBucket",
-                   encryption=type_KMS          # Compliant
-                   )
-
-my_encryption_key2 = aws_cdk.aws_kms.IKey() # Compliant
-bucket = s3.Bucket(self,"MyEncryptedBucket",
-                   encryption=s3.BucketEncryption.S3_MANAGED,
-                    encryption_key=my_encryption_key2)
-
-def create_bucket():
-    type_unencrypted = s3.BucketEncryption.UNENCRYPTED
-#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^> {{Propagated setting.}}
-    bucket = s3.Bucket(self,"MyEncryptedBucket",
-                       encryption=type_unencrypted,     # NonCompliant {{Objects in the bucket are not encrypted. Make sure it is safe here.}}
-#                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-                       encryption_key=my_encryption_key2)
-
-
-coverage = s3.Bucket(self, "bucket", encryption=unresolved_reference)  # Compliant
diff --git a/python-checks/src/test/resources/checks/cdk/unrestrictedAdministration_Connections.py b/python-checks/src/test/resources/checks/cdk/unrestrictedAdministration_Connections.py
index 605f5c9d54..1aad013c5f 100644
--- a/python-checks/src/test/resources/checks/cdk/unrestrictedAdministration_Connections.py
+++ b/python-checks/src/test/resources/checks/cdk/unrestrictedAdministration_Connections.py
@@ -62,6 +62,7 @@ def test_bad_port_variant(var):
 
         conn.allow_from(ec2.Peer.any_ipv4(), ec2.Port.all_tcp)
         conn.allow_from(ec2.Peer.any_ipv4(), ec2.Port.tcp(50))
+        conn.allow_from(ec2.Peer.any_ipv4(), ec2.Port.tcp(9223372036854775808))  # Compliant (port literal does not parse to long)
         conn.allow_from(ec2.Peer.any_ipv4(), ec2.Port.tcp(variable=3389))
         conn.allow_from(ec2.Peer.any_ipv4(), ec2.Port.tcp(port="3389"))
         conn.allow_from(ec2.Peer.any_ipv4(), ec2.Port.tcp_range(start_port=30, end_port=40))
diff --git a/python-checks/src/test/resources/checks/classFieldDefinedMultipleTimes.py b/python-checks/src/test/resources/checks/classFieldDefinedMultipleTimes.py
new file mode 100644
index 0000000000..b4e8f56a41
--- /dev/null
+++ b/python-checks/src/test/resources/checks/classFieldDefinedMultipleTimes.py
@@ -0,0 +1,233 @@
+class BasicDuplicate:
+    x = 1  # Noncompliant {{Remove this assignment; "x" is assigned again on line 4.}}
+#   ^
+    x = 3
+#   ^< {{Reassignment.}}
+    y = 2
+
+
+class CopyPasteError:
+    width = 100  # Noncompliant {{Remove this assignment; "width" is assigned again on line 13.}}
+#   ^^^^^
+    height = 200
+    width = 800
+#   ^^^^^< {{Reassignment.}}
+
+
+class RefactoringMistake:
+    timeout = 30  # Noncompliant {{Remove this assignment; "timeout" is assigned again on line 21.}}
+#   ^^^^^^^
+    host = "localhost"
+    timeout = 60
+#   ^^^^^^^< {{Reassignment.}}
+
+
+class AnnotatedThenPlain:
+    x: int = 0  # Noncompliant {{Remove this assignment; "x" is assigned again on line 28.}}
+#   ^
+    x = 1
+#   ^< {{Reassignment.}}
+
+
+class MultipleDuplicatePairs:
+    host = "localhost"  # Noncompliant
+    port = 8080  # Noncompliant
+    host = "production.example.com"
+    port = 443
+
+
+class ThreeAssignments:
+    status = 0  # Noncompliant
+    status = "pending"  # Noncompliant
+    status = "active"
+
+
+class NoneToValue:
+    max_length = None  # Noncompliant
+    max_results = 10
+    max_length = 512
+
+
+class BooleanFlip:
+    enable_cache = False  # Noncompliant
+    debug = True
+    enable_cache = True
+
+
+class TypeChange:
+    code = 0  # Noncompliant
+    code = "OK"
+
+
+class AnnotatedThenAnnotated:
+    value: int = 0  # Noncompliant
+    value: int = 42
+
+
+class DunderAttribute:
+    __slots__ = []  # Noncompliant
+    __slots__ = ["_name", "_value"]
+
+
+class LiteralTypes:
+    count = 0  # Noncompliant
+    label = "initial"  # Noncompliant
+    ratio = 0.5  # Noncompliant
+    count = 100
+    label = "final"
+    ratio = 1.0
+
+
+class UniqueFields:
+    x = 1
+    y = 2
+    z = 3
+
+
+class AugmentedAssignment:
+    count = 0
+    count += 1
+
+
+class AnnotationOnlyThenAssignment:
+    value: int
+    value = 42
+
+
+class ConditionalAssignments:
+    debug = False
+    if True:
+        debug = True
+
+
+class TryExceptPattern:
+    backend = "redis"
+    try:
+        backend = "memcached"
+    except ImportError:
+        pass
+
+
+class MethodSelfAssignments:
+    name = "default"
+
+    def __init__(self):
+        self.name = "instance"
+
+    def reset(self):
+        self.name = "reset"
+
+
+class ClassMethodAssignments:
+    total = 0
+
+    @classmethod
+    def increment(cls):
+        cls.total += 1
+
+
+class ForLoopAssignment:
+    items = []
+    for i in range(10):
+        items = [i]
+
+
+class WithStatementAssignment:
+    resource = None
+    with open("file.txt") as f:
+        resource = f.read()
+
+
+class WhileLoopAssignment:
+    retries = 0
+    while retries < 3:
+        retries = retries + 1
+
+
+class TupleUnpacking:
+    x = 0
+    y = 0
+    x, y = 1, 2
+
+
+class ChainedAssignment:
+    a = 0
+    b = 0
+    a = b = 5
+
+
+class AttributeAssignment:
+    x = 1
+    SomeClass.x = 2
+
+
+class SubscriptAssignment:
+    data = {}
+    data["key"] = "value"
+
+
+class NestedClassSameName:
+    x = 1
+
+    class Inner:
+        x = 10  # Noncompliant
+        x = 20
+
+
+class DifferentClasses:
+    x = 1
+
+
+class AnotherClass:
+    x = 2
+
+
+class NestedFunctionAssignment:
+    field = "class_level"
+
+    def setup(self):
+        field = "local"
+        field = "also_local"
+
+
+class ComplexAnnotationNoValue:
+    items: list[int]
+    items: list[str]
+    items = []
+
+
+class SingleAnnotatedAssignment:
+    version: str = "1.0.0"
+
+
+class AugmentedAfterAnnotated:
+    score: int = 0
+    score += 10
+
+
+class OnlyAnnotationsNoValues:
+    x: int
+    x: str
+
+
+class PlainThenAnnotated:
+    x = 1  # Noncompliant {{Remove this assignment; "x" is assigned again on line 216.}}
+#   ^
+    x: int = 42
+#   ^< {{Reassignment.}}
+
+
+class AnnotatedNonNameVariable:
+    SomeClass.attr: int = 0
+    data[0]: str = "x"
+
+
+class SameValueAssignedTwice:
+    _VERSION = "1.0"  # Noncompliant {{Remove this assignment; "_VERSION" is assigned again on line 232.}}
+#   ^^^^^^^^
+    _REQUEST_TOKEN_URL = "https://example.com/oauth/request_token"
+    _ACCESS_TOKEN_URL = "https://example.com/oauth/access_token"
+    _AUTHORIZE_URL = "https://example.com/oauth/authorize"
+    _NO_CALLBACKS = True
+    _VERSION = "1.0"
+#   ^^^^^^^^< {{Reassignment.}}
diff --git a/python-checks/src/test/resources/checks/consistentReturn.py b/python-checks/src/test/resources/checks/consistentReturn.py
index 62633c28f4..1b3cb84ebf 100644
--- a/python-checks/src/test/resources/checks/consistentReturn.py
+++ b/python-checks/src/test/resources/checks/consistentReturn.py
@@ -106,13 +106,91 @@ def implicit_return_on_match_statement(x): # Noncompliant
       return x
 #     ^^^^^^^^ < {{Return with value}}
 
-def match_statement_with_default(x): # Noncompliant
+def match_statement_with_default(x):
   match(x):
     case 0:
       return x
     case _:
       return 42
 
+def match_wildcard_return_or_raise(x):
+  match x:
+    case 1:
+      return 2
+    case _:
+      raise ValueError("error")
+
+def match_capture_pattern_all_return(x):
+  match x:
+    case 1:
+      return 2
+    case 2:
+      return 3
+    case other:
+      return other + 10
+
+def match_wildcard_with_guard(x): # Noncompliant
+  match x:
+    case 1:
+      return 2
+    case _ if x > 0:
+      return 3
+
+def match_irrefutable_not_last(x):
+  match x:
+    case _:
+      return 1
+    case 1:
+      return 2
+
+def match_irrefutable_in_middle(x):
+  match x:
+    case 0:
+      return 1
+    case _:
+      return 2
+    case 1:
+      pass
+
+def match_group_capture_is_irrefutable(x):
+  match x:
+    case 0:
+      return x
+    case (y):
+      return y
+
+
+def match_group_wildcard_is_irrefutable(x):
+  match x:
+    case 0:
+      return x
+    case (_):
+      return 42
+
+
+def match_nested_group_is_irrefutable(x):
+  match x:
+    case 0:
+      return x
+    case ((y)):
+      return y
+
+
+def match_guarded_group_is_refutable(x): # Noncompliant
+  match x:
+    case 0:
+      return x
+    case (y) if x > 0:
+      return y
+
+
+def match_group_literal_is_refutable(x): # Noncompliant
+  match x:
+    case 0:
+      return x
+    case (42):
+      return 42
+
 # raise / assert
 
 def return_value_or_raise(x):
@@ -182,3 +260,195 @@ def fp_on_undetected_raise(x): # Noncompliant
 
 def raise_error():
   raise "error"
+
+
+# Patterns from ruling analysis
+
+def find_match_in_loop(texts, frag):  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^
+  for t in texts:
+# ^^^ < {{Implicit return without value if the condition is false}}
+    if t is not frag and t.left > frag.right:
+      return t
+#     ^^^^^^^^ < {{Return with value}}
+
+def multiple_value_returns_with_bare_return(aug_tok1, params):  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  if not aug_tok1:
+    return
+#   ^^^^^^ < {{Return without value}}
+  if aug_tok1.period_final:
+    return "REASON_KNOWN_COLLOCATION"
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+  if aug_tok1.abbr:
+    return "REASON_ABBR"
+#   ^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+  return
+# ^^^^^^ < {{Return without value}}
+
+def return_only_in_else_branch(run_mode):  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^
+  if run_mode == 'v1':
+    do_v1_test()
+#   ^^^^^^^^^^^^ < {{Implicit return without value}}
+  elif run_mode == 'v2':
+    do_v2_test()
+#   ^^^^^^^^^^^^ < {{Implicit return without value}}
+  else:
+    return ValueError('Unknown run mode %s' % run_mode)
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+
+
+class MyClass:
+  def value_or_none(self): # Noncompliant
+#     ^^^^^^^^^^^^^
+    if self.condition:
+#   ^^ < {{Implicit return without value if the condition is false}}
+      return self._value
+#     ^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+
+  def always_returns_none_or_value(self):
+    if self.condition:
+      return self._value
+    return None
+
+  @property
+  def linked_object(self): # Noncompliant
+#     ^^^^^^^^^^^^^
+    if self.link_type == "a":
+      return self.a
+#     ^^^^^^^^^^^^^ < {{Return with value}}
+    elif self.link_type == "b":
+      return self.b
+#     ^^^^^^^^^^^^^ < {{Return with value}}
+    elif self.link_type == "c":
+      return self.c
+#     ^^^^^^^^^^^^^ < {{Return with value}}
+    elif self.link_type == "d":
+#   ^^^^ < {{Implicit return without value if the condition is false}}
+      return self.d
+#     ^^^^^^^^^^^^^ < {{Return with value}}
+
+
+def outer_with_nested(params):
+  def handler(cursor): # Noncompliant
+#     ^^^^^^^
+    if cursor.bindvars is None:
+      return
+#     ^^^^^^ < {{Return without value}}
+    if isinstance(cursor.bindvars, list):
+      return [v.getvalue() for v in cursor.bindvars]
+#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+    if isinstance(cursor.bindvars, dict):
+      return {n: v.getvalue() for n, v in cursor.bindvars.items()}
+#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+    raise TypeError("Unexpected bindvars")
+
+  result = run(handler)
+  return result
+
+
+def boundaries(start, end): # Noncompliant
+#   ^^^^^^^^^^
+  if not isinstance(start, int):
+    raise TypeError("expected int")
+  if not isinstance(end, int):
+    raise TypeError("expected int")
+  if start > end:
+    start, end = end, start
+  if start < end:
+# ^^ < {{Implicit return without value if the condition is false}}
+    return start, end
+#   ^^^^^^^^^^^^^^^^^ < {{Return with value}}
+
+
+class MiddlewareMixin:
+  @staticmethod
+  def process_request(request): # Noncompliant
+#     ^^^^^^^^^^^^^^^
+    if not request.user.is_authenticated:
+#   ^^ < {{Implicit return without value if the condition is false}}
+      if request.path not in IGNORE_URL:
+#     ^^ < {{Implicit return without value if the condition is false}}
+        return redirect('/login/')
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+
+
+class WebhookPlugin:
+  def order_fully_paid(self, order, previous_value): # Noncompliant
+#     ^^^^^^^^^^^^^^^^
+    if not self.active:
+      return previous_value
+#     ^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+    event_type = "ORDER_FULLY_PAID"
+    if webhooks := get_webhooks_for_event(event_type):
+#   ^^ < {{Implicit return without value if the condition is false}}
+      trigger_webhooks_async(webhooks)
+#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ < {{Implicit return without value}}
+
+
+class CacheFactory:
+  @classmethod
+  def factory(cls, backend, ttl): # Noncompliant
+#     ^^^^^^^
+    if backend == "memory":
+      return CacheDict(ttl)
+#     ^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+    elif backend == "disk":
+      return CacheDisk(ttl)
+#     ^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+    else:
+      log.error("unrecognized cache type")
+#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ < {{Implicit return without value}}
+
+
+@lru_cache()
+def cached_lookup(locale): # Noncompliant
+#   ^^^^^^^^^^^^^
+  name = get_name(locale)
+  if name is not None:
+# ^^ < {{Implicit return without value if the condition is false}}
+    return load_resource(name)
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+
+
+@some_hook(flag=True)
+def announce_header(**kwargs): # Noncompliant
+#   ^^^^^^^^^^^^^^^
+  if not session.user or config.DISABLE_CHECK:
+    return
+#   ^^^^^^ < {{Return without value}}
+  if down:
+    text = "scheduler not running"
+  elif mismatch:
+    text = "version mismatch"
+  else:
+    return
+#   ^^^^^^ < {{Return without value}}
+  return 'error', text, True
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^ < {{Return with value}}
+
+
+def early_sentinel_value_return(path, conn=None): # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  if conn is None:
+    conn = get_conn()
+  if conn is False:
+    return False
+#   ^^^^^^^^^^^^ < {{Return with value}}
+  for comp in path.split("/"):
+# ^^^ < {{Implicit return without value if the condition is false}}
+    process(comp)
+
+
+class SearchHelper:
+  def dup_check(self, sequence): # Noncompliant
+#     ^^^^^^^^^
+    for sc in self.all_shortcuts:
+#   ^^^ < {{Implicit return without value if the condition is false}}
+      if sc is self.shortcut:
+        continue
+      for k in sc['keys']:
+        if k == sequence:
+          return sc['name']
+#         ^^^^^^^^^^^^^^^^^ < {{Return with value}}
diff --git a/python-checks/src/test/resources/checks/dataClassFunctionCallDefault.py b/python-checks/src/test/resources/checks/dataClassFunctionCallDefault.py
new file mode 100644
index 0000000000..a04c405011
--- /dev/null
+++ b/python-checks/src/test/resources/checks/dataClassFunctionCallDefault.py
@@ -0,0 +1,292 @@
+import dataclasses
+import random
+import uuid
+import time
+import secrets
+import os
+from dataclasses import dataclass, field
+from datetime import datetime, date
+from typing import ClassVar
+
+
+# Known problematic factory calls are flagged
+
+@dataclass
+class Event:
+    timestamp: datetime = datetime.now()  # Noncompliant {{Use "field(default_factory=...)" instead of a function call as a default value.}}
+#                         ^^^^^^^^^^^^^^
+    event_id: str = uuid.uuid4()  # Noncompliant
+    today: date = date.today()  # Noncompliant
+    started_at: float = time.time()  # Noncompliant
+    token: str = secrets.token_hex(16)  # Noncompliant
+    rand_bytes: bytes = os.urandom(16)  # Noncompliant
+
+
+# random.* top-level functions are aliased from a Random() instance in typeshed
+# (`randint = _inst.randint`), so isType("random.randint") resolves to Unknown.
+# We work around this by matching on the random module qualifier and the function name.
+
+@dataclass
+class EventWithRandom:
+    number: int = random.randint(1, 100)  # Noncompliant
+#                 ^^^^^^^^^^^^^^^^^^^^^^
+    pick: int = random.choice([1, 2, 3])  # Noncompliant
+    coin: float = random.random()  # Noncompliant
+
+
+# Aliased imports: `from random import randint as r` makes the callee just `r`,
+# not a QualifiedExpression on the random module — accepted FN.
+
+from random import randint as _aliased_randint
+
+@dataclass
+class EventWithAliasedRandom:
+    number: int = _aliased_randint(1, 100)  # Compliant: accepted FN (no random qualifier)
+
+
+# Method calls on a Random() instance: the callee qualifier is not the random module,
+# so the syntactic workaround does not fire. The full type chain DOES resolve here
+# (random.Random.randint is a known FunctionType) but it is not in the allowlist.
+
+@dataclass
+class EventWithRandomInstance:
+    rng: random.Random = random.Random()  # Compliant: constructor of a frozen-ish helper
+    n: int = random.Random().randint(1, 100)  # Compliant: accepted FN (qualifier is a Random instance)
+
+
+# Mutable container constructor calls are flagged — each instance would share the same container
+
+@dataclass
+class EventWithContainers:
+    items: list = list()  # Noncompliant
+    mapping: dict = dict()  # Noncompliant
+    tags: set = set()  # Noncompliant
+    buffer: bytearray = bytearray()  # Noncompliant
+
+
+# Mutable literal defaults are flagged
+
+@dataclass
+class EventWithLiterals:
+    items: list = []  # Noncompliant
+#                 ^^
+    mapping: dict = {}  # Noncompliant
+    tags: set = {1, 2, 3}  # Noncompliant
+
+
+# dataclasses.dataclass qualified name
+
+@dataclasses.dataclass
+class Record:
+    created: datetime = datetime.now()  # Noncompliant
+
+
+# dataclass with arguments (frozen, eq, ...)
+
+@dataclass(frozen=True)
+class FrozenEvent:
+    timestamp: datetime = datetime.now()  # Noncompliant
+
+
+@dataclasses.dataclass(eq=True, order=True)
+class OrderedEvent:
+    created: datetime = datetime.now()  # Noncompliant
+
+
+# Compliant: call to a user-defined function — not in the allowlist.
+# The allowlist-based approach accepts FNs here in exchange for FP-free behavior.
+
+def compute_default():
+    return 42
+
+@dataclass
+class WithUserCall:
+    value: int = compute_default()  # Compliant: accepted FN
+
+
+# Compliant: field(default_factory=...)
+
+@dataclass
+class CompliantEvent:
+    timestamp: datetime = field(default_factory=datetime.now)
+    event_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    items: list = field(default_factory=list)
+
+
+# Compliant: field(default=...) with a constant
+
+@dataclass
+class FieldWithDefault:
+    value: int = field(default=0)
+    name: str = field(default="foo")
+
+
+# field(default=problematic_call()) is flagged — the inner call is evaluated once at
+# class definition, same bug as writing the call directly
+
+@dataclass
+class FieldWithProblematicDefault:
+    timestamp: datetime = field(default=datetime.now())  # Noncompliant
+#                                       ^^^^^^^^^^^^^^
+    event_id: str = field(default=uuid.uuid4())  # Noncompliant
+    today: date = dataclasses.field(default=date.today())  # Noncompliant
+    items: list = field(default=[])  # Noncompliant
+    mapping: dict = field(default={})  # Noncompliant
+    more_items: list = field(default=list())  # Noncompliant
+    number: int = field(default=random.randint(1, 100))  # Noncompliant
+
+
+# Compliant: field(default=...) with a non-problematic call (user-defined helper not in allowlist)
+
+@dataclass
+class FieldWithSafeDefault:
+    value: int = field(default=compute_default())  # Compliant: accepted FN
+
+
+# Compliant: dataclasses.field(...) qualified
+
+@dataclass
+class QualifiedField:
+    value: int = dataclasses.field(default_factory=int)
+
+
+# Compliant: constant default values
+
+@dataclass
+class Constants:
+    integer: int = 0
+    string: str = "hello"
+    flag: bool = True
+    nothing: None = None
+    floating: float = 1.5
+    tuple_val: tuple = ()
+
+
+# Compliant: no default value
+
+@dataclass
+class NoDefault:
+    name: str
+    age: int
+
+
+# Compliant: non-dataclass class — rule only applies to dataclasses
+
+class RegularClass:
+    timestamp: datetime = datetime.now()
+    event_id: str = str(uuid.uuid4())
+
+
+# Compliant: class variable (ClassVar) — intentionally class-level
+
+@dataclass
+class WithClassVar:
+    shared: ClassVar[datetime] = datetime.now()
+
+
+# Nested dataclass
+
+@dataclass
+class Outer:
+    name: str = "foo"
+
+    @dataclass
+    class Inner:
+        timestamp: datetime = datetime.now()  # Noncompliant
+
+
+# Compliant: attribute access (not a call) on a call result is not the top-level expression
+
+CONSTANT = 42
+
+@dataclass
+class WithAttributeAccess:
+    value: int = CONSTANT
+
+
+# Compliant: arithmetic on constants
+
+@dataclass
+class WithBinaryOps:
+    value: int = 1 + 2
+    other: int = -1
+
+
+# Method body: only attributes annotated at class level are considered
+
+@dataclass
+class NoAnnotation:
+    name: str = "foo"
+
+    def method(self):
+        local_var = datetime.now()
+        return local_var
+
+
+# Unknown decorator (not dataclass) — compliant
+
+@unknown_decorator
+class NotADataclass:
+    timestamp: datetime = datetime.now()
+
+
+# Regular assignment (not annotated) — no type annotation, not a dataclass field
+
+@dataclass
+class RegularAssignment:
+    x = datetime.now()  # Compliant: without type annotation, not a dataclass field
+
+
+# Compliant: user-defined classmethod helper named "field" that wraps
+# dataclasses.field(default_factory=...). Common in LibCST (CSTNode.field).
+# Under the allowlist philosophy, this is naturally compliant because the callee's
+# FQN is not in the problematic list.
+
+class Base:
+    @classmethod
+    def field(cls, *args, **kwargs):
+        return field(default_factory=lambda: cls(*args, **kwargs))
+
+
+@dataclass(frozen=True)
+class Derived(Base):
+    value: str = ""
+
+
+@dataclass
+class UsingFieldHelper:
+    derived: Derived = Derived.field("")  # Compliant: wrapper around dataclasses.field
+    other: Derived = Base.field("")  # Compliant: wrapper around dataclasses.field
+
+
+# Compliant: constructor call (user-defined frozen dataclass). The constructor is not in
+# the allowlist, so we accept this as an FN. Frozen dataclass instances are immutable,
+# so sharing the default across instances is usually safe anyway.
+
+@dataclass(frozen=True)
+class Shared:
+    name: str = "x"
+
+
+@dataclass
+class UsesShared:
+    inner: Shared = Shared()  # Compliant: accepted FN
+
+
+# Time via aliased import is still flagged — FQN still resolves to time.time
+
+from time import time as now_ts
+
+@dataclass
+class WithAliasedTime:
+    started: float = now_ts()  # Noncompliant
+
+
+# Compliant: function call whose FQN cannot be resolved — unknown callee means no match
+
+def _maker():
+    return datetime.now()
+
+@dataclass
+class WithUnknownCallee:
+    ts: datetime = _maker()  # Compliant: accepted FN (callee not in allowlist)
diff --git a/python-checks/src/test/resources/checks/dataClassOnEnum.py b/python-checks/src/test/resources/checks/dataClassOnEnum.py
new file mode 100644
index 0000000000..6a0af22829
--- /dev/null
+++ b/python-checks/src/test/resources/checks/dataClassOnEnum.py
@@ -0,0 +1,193 @@
+from dataclasses import dataclass
+from enum import Enum, IntEnum, Flag, IntFlag, StrEnum
+import dataclasses
+
+
+# @dataclass on Enum - Noncompliant cases
+
+@dataclass  # Noncompliant {{Remove this "@dataclass" decorator; it is incompatible with Enum classes.}}
+class Status(Enum):
+    PENDING = 1
+    APPROVED = 2
+    REJECTED = 3
+
+
+# @dataclass with arguments
+
+@dataclass(frozen=True)  # Noncompliant
+class Color(Enum):
+    RED = 1
+    GREEN = 2
+    BLUE = 3
+
+
+# Using dataclasses.dataclass qualified name
+
+@dataclasses.dataclass  # Noncompliant
+class Direction(Enum):
+    NORTH = "N"
+    SOUTH = "S"
+    EAST = "E"
+    WEST = "W"
+
+
+@dataclasses.dataclass(eq=True, order=True)  # Noncompliant
+class Priority(Enum):
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+
+
+# @dataclass on IntEnum and Flag (transitively extend Enum)
+
+@dataclass  # Noncompliant
+class ErrorCode(IntEnum):
+    NOT_FOUND = 404
+    SERVER_ERROR = 500
+
+
+@dataclass  # Noncompliant
+class Permission(Flag):
+    READ = 1
+    WRITE = 2
+    EXECUTE = 4
+
+
+@dataclass  # Noncompliant
+class FileMode(IntFlag):
+    READ = 4
+    WRITE = 2
+    EXECUTE = 1
+
+
+# @dataclass on StrEnum (Python 3.11+)
+
+@dataclass  # Noncompliant
+class HttpMethod(StrEnum):
+    GET = "GET"
+    POST = "POST"
+
+
+# @dataclass on an indirect Enum subclass
+
+class BaseStatus(Enum):
+    pass
+
+@dataclass  # Noncompliant
+class ExtendedStatus(BaseStatus):
+    PENDING = 1
+    ACTIVE = 2
+
+
+# @dataclass among multiple decorators
+
+def my_decorator(cls):
+    return cls
+
+@my_decorator
+@dataclass  # Noncompliant
+class State(Enum):
+    OPEN = "open"
+    CLOSED = "closed"
+
+
+@dataclass  # Noncompliant
+@my_decorator
+class Stage(Enum):
+    START = 1
+    END = 2
+
+
+# @dataclass with multiple keyword arguments
+
+@dataclass(repr=False, eq=False)  # Noncompliant
+class Suit(Enum):
+    HEARTS = 1
+    DIAMONDS = 2
+    CLUBS = 3
+    SPADES = 4
+
+
+# @dataclass on class with multiple bases including Enum
+
+class Mixin:
+    pass
+
+@dataclass  # Noncompliant
+class Mixed(Mixin, Enum):
+    FIRST = 1
+    SECOND = 2
+
+
+# Compliant: Enum without @dataclass
+
+class CompliantStatus(Enum):
+    PENDING = 1
+    APPROVED = 2
+    REJECTED = 3
+
+
+class CompliantErrorCode(IntEnum):
+    NOT_FOUND = 404
+    SERVER_ERROR = 500
+
+
+class CompliantPermission(Flag):
+    READ = 1
+    WRITE = 2
+    EXECUTE = 4
+
+
+class CompliantHttpMethod(StrEnum):
+    GET = "GET"
+    POST = "POST"
+
+
+# Compliant: @dataclass on a plain class (not Enum)
+
+@dataclass
+class Point:
+    x: float
+    y: float
+
+
+@dataclass(frozen=True)
+class Config:
+    host: str
+    port: int
+
+
+@dataclasses.dataclass
+class Rectangle:
+    width: float
+    height: float
+
+
+# Compliant: custom (non-dataclass) decorator on an Enum
+
+@my_decorator
+class DecoratedStatus(Enum):
+    ACTIVE = 1
+    INACTIVE = 2
+
+
+# Compliant: Enum subclass without @dataclass
+
+class CompliantExtended(BaseStatus):
+    ACTIVE = 1
+    INACTIVE = 2
+
+
+# Compliant: unknown base class — cannot confirm Enum inheritance
+
+@dataclass
+class UnknownBase(UnknownParent):
+    value: int = 0
+
+
+# Compliant: unknown decorator on an Enum — not a dataclass
+
+@unknown_decorator
+class StatusWithUnknownDecorator(Enum):
+    ACTIVE = 1
+    INACTIVE = 2
diff --git a/python-checks/src/test/resources/checks/dataclassFieldDefinition.py b/python-checks/src/test/resources/checks/dataclassFieldDefinition.py
new file mode 100644
index 0000000000..10ed93cff7
--- /dev/null
+++ b/python-checks/src/test/resources/checks/dataclassFieldDefinition.py
@@ -0,0 +1,213 @@
+from dataclasses import dataclass, field, InitVar
+from datetime import datetime
+from typing import ClassVar, Optional
+
+
+# =======================
+# Issues
+# =======================
+
+@dataclass
+class SingleUnannotatedAttribute:
+    timeout = 30  # Noncompliant {{Add a type annotation to this dataclass attribute.}}
+#   ^^^^^^^^^^^^
+
+
+@dataclass
+class MultipleUnannotatedAttributes:
+    timeout = 30   # Noncompliant {{Add a type annotation to this dataclass attribute.}}
+#   ^^^^^^^^^^^^
+    retries = 3    # Noncompliant {{Add a type annotation to this dataclass attribute.}}
+#   ^^^^^^^^^^^
+
+
+@dataclass
+class MixedAnnotatedAndUnannotated:
+    name: str = "default"
+    timeout = 30  # Noncompliant
+#   ^^^^^^^^^^^^
+
+
+@dataclass(frozen=True)
+class FrozenDataclassUnannotated:
+    timeout = 30  # Noncompliant
+
+
+@dataclass
+class MultipleViolations:
+    unannotated = 42                       # Noncompliant
+    other = "value"                        # Noncompliant
+
+
+import dataclasses
+
+@dataclasses.dataclass
+class QualifiedDecoratorNoncompliant:
+    unannotated = 42  # Noncompliant
+
+
+@dataclass
+class ChildDataclassWithViolation:
+    unannotated = 99  # Noncompliant
+    extra: int = 0
+
+
+def outer_function():
+    # FN: type inference resolves `@dataclass` to Unknown when the decorated class is nested in a function
+    @dataclass
+    class InnerDataclass:
+        value = 10
+        name: str = ""
+
+
+# =======================
+# Compliant
+# =======================
+
+class RegularClassWithUnannotatedAttrs:
+    timeout = 30
+    retries = 3
+
+
+@dataclass
+class ImmutableScalarDefaults:
+    count: int = 0
+    name: str = ""
+    flag: bool = False
+    ratio: float = 1.0
+
+
+@dataclass
+class NoneDefault:
+    opt: Optional[str] = None
+
+
+@dataclass
+class MutableDefaultsAreNotFlagged:
+    members: list = []
+    config: dict = {}
+    tags: set = {1, 2}
+
+
+@dataclass
+class CallDefaultsAreNotFlagged:
+    items: list = list()
+    config: dict = dict()
+    buffer: bytearray = bytearray()
+    created_at: datetime = datetime.now()
+    allowed: frozenset = frozenset([1, 2, 3])
+    tags: set = set()
+
+
+@dataclass
+class FieldDefaultFactoryCompliant:
+    members: list = field(default_factory=list)
+    config: dict = field(default_factory=dict)
+    created_at: datetime = field(default_factory=datetime.now)
+
+
+@dataclass
+class FieldDefaultCompliant:
+    count: int = field(default=0)
+    name: str = field(default="hello")
+    derived: int = field(init=False, default=0)
+
+
+@dataclass
+class ClassVarAnnotations:
+    count: ClassVar[int] = 5
+    items: ClassVar[list] = []
+    metadata: ClassVar[dict] = {}
+
+
+@dataclass
+class ClassVarBareForm:
+    count: ClassVar = 0
+
+
+@dataclass
+class InitVarAnnotations:
+    init_value: InitVar[int] = 1
+    init_param: InitVar[str] = "default"
+
+
+@dataclass
+class NoDefaultAnnotatedFields:
+    x: float
+    y: int
+    name: str
+
+
+@dataclass
+class OptionalWithNoneDefault:
+    label: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class FrozenDataclassCompliant:
+    name: str = ""
+    items: list = field(default_factory=list)
+
+
+@dataclasses.dataclass
+class QualifiedDecoratorCompliant:
+    name: str = ""
+    count: int = 0
+
+
+def make_default_list():
+    return []
+
+@dataclass
+class CustomFactoryCompliant:
+    items: list = field(default_factory=make_default_list)
+
+
+@dataclass
+class TupleLiteralDefault:
+    coords: tuple = (0, 0)
+
+
+@dataclass
+class NestedCallDefault:
+    value: str = str(object())
+
+
+@dataclass
+class EmptyDataclass:
+    pass
+
+
+@dataclass
+class DataclassWithOnlyMethods:
+    name: str
+
+    def get_name(self) -> str:
+        return self.name
+
+
+@dataclass
+class ParentDataclass:
+    name: str = ""
+
+
+class NonDataclassChild(ParentDataclass):
+    unannotated = 99
+
+
+# ALL_CAPS names follow the Python constant convention and are intentional class-level attributes
+@dataclass
+class AllCapsConstants:
+    MAX_RETRIES = 5
+    DEFAULT_TIMEOUT = 30
+    BASE_URL = "https://example.com"
+
+
+# Names starting with _ are considered intentional private/special attributes
+@dataclass
+class UnderscorePrefixedAttributes:
+    _private = "value"
+    __slots__ = ['x', 'y']
+    __tablename__ = "users"
+    __abstract__ = True
+    _PRIVATE_CONST = 42
diff --git a/python-checks/src/test/resources/checks/datetime_constructor_pytz_timezone.py b/python-checks/src/test/resources/checks/datetime_constructor_pytz_timezone.py
index a178e4d6f6..459eb8fa1d 100644
--- a/python-checks/src/test/resources/checks/datetime_constructor_pytz_timezone.py
+++ b/python-checks/src/test/resources/checks/datetime_constructor_pytz_timezone.py
@@ -13,7 +13,9 @@ def timezone_in_a_variable():
     return dt1
 
 some_timezone_1 = pytz.timezone('US/Eastern')
-dt1 = datetime.datetime(2022, 1, 1, tzinfo=some_timezone_1)  # FN because of ReachingDefinitionsAnalysis limitations : it only runs in functions
+                 #^^^^^^^^^^^^^^^^^^^^^^^^^^^> 1 {{The pytz.timezone is created here.}}
+dt1 = datetime.datetime(2022, 1, 1, tzinfo=some_timezone_1)  # Noncompliant {{Don't pass a "pytz.timezone" to the "datetime.datetime" constructor.}}
+                                   #^^^^^^^^^^^^^^^^^^^^^^
 
 def compliant():
     other_timezone = datetime.timezone(datetime.timedelta(hours=2))
diff --git a/python-checks/src/test/resources/checks/datetime_constructor_use_timezone_aware.py b/python-checks/src/test/resources/checks/datetime_constructor_use_timezone_aware.py
index 0062998d20..85293a6532 100644
--- a/python-checks/src/test/resources/checks/datetime_constructor_use_timezone_aware.py
+++ b/python-checks/src/test/resources/checks/datetime_constructor_use_timezone_aware.py
@@ -1,27 +1,39 @@
 def some_function():
     from datetime import datetime
-    datetime.utcnow() # Noncompliant {{Don't use `datetime.datetime.utcnow` to create this datetime object.}}
-   #^^^^^^^^^^^^^^^^^
+
+    datetime.utcnow()  # Noncompliant {{Don't use `datetime.datetime.utcnow` to create this datetime object.}}
+#   ^^^^^^^^^^^^^^^
     timestamp = 1571595618.0
-    datetime.utcfromtimestamp(timestamp) # Noncompliant {{Don't use `datetime.datetime.utcfromtimestamp` to create this datetime object.}}
-   #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    datetime.utcfromtimestamp(  # Noncompliant {{Don't use `datetime.datetime.utcfromtimestamp` to create this datetime object.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^
+        timestamp
+    )
+
 
 def other_function():
     import datetime
+
     timestamp = 1571595618.0
-    datetime.datetime.utcnow() # Noncompliant
-    datetime.datetime.utcfromtimestamp(timestamp) # Noncompliant
+    datetime.datetime.utcnow()  # Noncompliant
+    datetime.datetime.utcfromtimestamp(timestamp)  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    test = "test"
+    a = f"test/{datetime.datetime.utcnow().strftime('%Y-%m-%d')}/{str(test)}"  # Noncompliant
+#               ^^^^^^^^^^^^^^^^^^^^^^^^
 
     from datetime import datetime as dt
-    dt.utcnow() # Noncompliant
-    dt.utcfromtimestamp(timestamp) # Noncompliant
 
-def unknown_symbols():
+    dt.utcnow()  # Noncompliant
+    dt.utcfromtimestamp(timestamp)  # Noncompliant
+
 
+def unknown_symbols():
     unrelated_call()
 
-    datetime.datetime.utcnow()
-    datetime.datetime.utcfromtimestamp()
+    datetime.datetime.utcnow()  # Noncompliant
+    datetime.datetime.utcfromtimestamp()  # Noncompliant
+
 
 def compliant_examples():
     from datetime import datetime, timezone
@@ -30,11 +42,13 @@ def compliant_examples():
     timestamp = 1571595618.0
     datetime.fromtimestamp(timestamp, timezone.utc)
 
+
 def aliased_utcnow():
     from datetime import datetime
+
     reassigned = datetime.utcnow
-    # FN because we lose the FQN in the assignment
-    reassigned()
+    reassigned()  # Noncompliant
 
     from datetime import datetime as aliased
-    aliased.utcnow() # Noncompliant
+
+    aliased.utcnow()  # Noncompliant
diff --git a/python-checks/src/test/resources/checks/deprecatedNumpyTypesCheck.py b/python-checks/src/test/resources/checks/deprecatedNumpyTypesCheck.py
index ecf6045fcc..6cee377428 100644
--- a/python-checks/src/test/resources/checks/deprecatedNumpyTypesCheck.py
+++ b/python-checks/src/test/resources/checks/deprecatedNumpyTypesCheck.py
@@ -2,8 +2,6 @@
 
 
 def failure():
-    b = np.bool(True)  # Noncompliant {{Replace this deprecated "numpy" type alias with the builtin type "bool".}}
-    #   ^^^^^^^
     i = np.int(42)  # Noncompliant {{Replace this deprecated "numpy" type alias with the builtin type "int".}}
     #   ^^^^^^
     f = np.float(4.2)  # Noncompliant {{Replace this deprecated "numpy" type alias with the builtin type "float".}}
@@ -21,8 +19,6 @@ def failure():
 
 def failure_import_as_z():
     import numpy as z
-    b = z.bool(True)  # Noncompliant
-    #   ^^^^^^
     i = z.int(42)  # Noncompliant
     #   ^^^^^
     f = z.float(4.2)  # Noncompliant
@@ -39,6 +35,8 @@ def failure_import_as_z():
     #   ^^^^^^^^^
 
 def success():
+    b = np.bool(True)
+    b = np.bool(False)
     b = True  # Compliant
     b = bool(True)  # Compliant
     i = 42  # Compliant
@@ -54,3 +52,12 @@ def success():
     u = "bar"  # Compliant
     u = str("bar")  # Compliant
 
+def success_np_bool_usages():
+    # np.bool is no longer deprecated (reintroduced in NumPy 2.x)
+    arr = np.zeros(2).astype(np.bool)
+    mask = np.ones((3, 4), dtype=np.bool)
+    empty = np.zeros_like(arr, dtype=np.bool)
+    if arr.dtype == np.bool:
+        pass
+    dtype = np.bool
+
diff --git a/python-checks/src/test/resources/checks/dictKeysMembershipTest.py b/python-checks/src/test/resources/checks/dictKeysMembershipTest.py
new file mode 100644
index 0000000000..e5368056a1
--- /dev/null
+++ b/python-checks/src/test/resources/checks/dictKeysMembershipTest.py
@@ -0,0 +1,40 @@
+def noncompliant_basic():
+    my_dict = {'a': 1, 'b': 2}
+    if 'a' in my_dict.keys():  # Noncompliant {{Remove this unnecessary "keys()" call.}}
+#             ^^^^^^^^^^^^^^
+        print('Found')
+
+
+def noncompliant_not_in():
+    my_dict = {'a': 1, 'b': 2}
+    if 'a' not in my_dict.keys():  # Noncompliant {{Remove this unnecessary "keys()" call.}}
+#                 ^^^^^^^^^^^^^^
+        print('Not found')
+
+
+def compliant_direct_membership():
+    my_dict = {'a': 1, 'b': 2}
+    if 'a' in my_dict:
+        print('Found')
+
+
+def compliant_keys_with_argument():
+    my_dict = {'a': 1}
+    if 'a' in my_dict.keys('unexpected'):
+        print('Not flagged')
+
+
+def compliant_values_call():
+    my_dict = {'a': 1, 'b': 2}
+    if 1 in my_dict.values():
+        print('Found value')
+
+
+def compliant_custom_class():
+    class CustomMapping:
+        def keys(self):
+            return ['x', 'y']
+
+    obj = CustomMapping()
+    if 'x' in obj.keys():
+        print('Found')
diff --git a/python-checks/src/test/resources/checks/django/migrations/0001_generated_migration.py b/python-checks/src/test/resources/checks/django/migrations/0001_generated_migration.py
new file mode 100644
index 0000000000..2d46a8f774
--- /dev/null
+++ b/python-checks/src/test/resources/checks/django/migrations/0001_generated_migration.py
@@ -0,0 +1,41 @@
+from django.db import migrations, models
+
+
+# if legacy_users:
+#     migrate_users()
+"""if legacy_users:
+    migrate_users()
+"""
+
+
+def copy_legacy_users(apps, schema_editor):
+    if apps is None:
+        return
+    if schema_editor is None:
+        return
+    if schema_editor.connection.alias == "default":
+        if apps.get_model("accounts", "User").objects.exists():
+            return
+        for user in apps.get_model("legacy", "User").objects.all():
+            if user.is_active:
+                if user.email:
+                    continue
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("accounts", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="raffle",
+            name="address_req",
+            field=models.CharField(
+                choices=[("REQ", "Address required"), ("OPT", "Address required"), ("NOT", "Address required")],
+                default="NOT",
+                max_length=3,
+            ),
+        ),
+        migrations.RunPython(copy_legacy_users, migrations.RunPython.noop),
+    ]
diff --git a/python-checks/src/test/resources/checks/doublePrefixOperator.py b/python-checks/src/test/resources/checks/doublePrefixOperator.py
index bdf6618625..75a47cb1aa 100644
--- a/python-checks/src/test/resources/checks/doublePrefixOperator.py
+++ b/python-checks/src/test/resources/checks/doublePrefixOperator.py
@@ -7,7 +7,7 @@ def start():
     #   ^^^
     d = not (not (not (not a)))  # Noncompliant 3
 
-    e = ~~~~~a  # Noncompliant
+    e = ~~~~~a  # Noncompliant 4
     f = ~(((((~a)))))  # Noncompliant {{Use the "~" operator just once or not at all.}}
 
     g = not (a == b)
diff --git a/python-checks/src/test/resources/checks/duplicateBaseClass.py b/python-checks/src/test/resources/checks/duplicateBaseClass.py
new file mode 100644
index 0000000000..5e01530fa8
--- /dev/null
+++ b/python-checks/src/test/resources/checks/duplicateBaseClass.py
@@ -0,0 +1,99 @@
+from os import PathLike
+import my_class
+from my_class import A, B, C, X, mixin
+import a
+import mod
+# Examples with issues:
+
+# Duplicate base with a resolved fully-qualified symbol (exercises the FQN path in expressionKey)
+class ResolvedSymbolDuplicate(PathLike, PathLike): # Noncompliant {{Remove this duplicate base class.}}
+#                             ^^^^^^^^  ^^^^^^^^< {{Already listed here.}}
+    pass
+
+class SimpleEndDuplicate(A, B, A): # Noncompliant {{Remove this duplicate base class.}}
+#                        ^     ^< {{Already listed here.}}
+    pass
+
+class MidAndEndDuplicate(A, B, my_class.B): # Noncompliant {{Remove this duplicate base class.}}
+#                           ^  ^^^^^^^^^^< {{Already listed here.}}
+    pass
+
+class QualifiedDuplicate(mod.Base, Other, mod.Base): # Noncompliant {{Remove this duplicate base class.}}
+#                        ^^^^^^^^         ^^^^^^^^< {{Already listed here.}}
+    pass
+
+# One issue with two secondaries (2nd and 3rd are duplicates of 1st)
+class TripleDuplicate(A, A, A): # Noncompliant {{Remove this duplicate base class.}}
+#                     ^  ^< {{Already listed here.}}
+#                           ^@-1< {{Already listed here.}}
+    pass
+
+# metaclass keyword argument is skipped, duplicate among positional bases still flagged
+class WithMetaclassDuplicate(A, B, A, metaclass=Meta): # Noncompliant
+    pass
+
+# Two separate groups of duplicates (2 issues: one for A, one for B)
+class TwoPairsDuplicates(A, B, A, B): # Noncompliant 2
+    pass
+
+class ManyBasesDuplicate(A, B, C, D, B): # Noncompliant
+    pass
+
+class DeepQualifiedDuplicate(a.b.C, D, a.b.C): # Noncompliant
+    pass
+
+# One issue with two secondaries (2nd and 3rd are duplicates of 1st)
+class ThreeTimeDuplicate(mixin, mixin, mixin): # Noncompliant
+#                        ^^^^^  ^^^^^< ^^^^^<
+    pass
+
+# Star-unpacking is skipped; duplicate among remaining RegularArguments is still detected
+class StarAndDuplicate(*extra, A, A): # Noncompliant
+    pass
+
+# Name with a symbol but no fully-qualified name (parameter symbol has no FQN)
+def make_class(other):
+    class Inner(other, other): # FN
+        pass
+
+# Compliant examples:
+
+class NoBaseClass:
+    pass
+
+class SingleBase(A):
+    pass
+
+class MultipleUnique(A, B, C):
+    pass
+
+class MultipleUniqueQualified(mod.A, mod.B, mod.C):
+    pass
+
+class OnlyMetaclass(metaclass=Meta):
+    pass
+
+class UniqueBasesWithMetaclass(A, B, metaclass=Meta):
+    pass
+
+# Subscript expressions yield a null key, so duplicates are not detected
+class GenericSubscript(Generic[T]):
+    pass
+
+class TwoIdenticalSubscripts(Generic[T], Generic[T]):
+    pass
+
+class SubscriptAndName(Generic[T], Base):
+    pass
+
+# Call expressions yield a null key, so duplicates are not detected
+class TwoCallBases(make_base(), make_base()):
+    pass
+
+# Qualified name whose qualifier is a call result — null key, no issue
+class CallQualifiedBase(obj.method().Attr, obj.method().Attr):
+    pass
+
+# Deep qualified expression where an intermediate qualifier is a call result — null key via recursive path
+class DeepCallQualifiedBase(a.b().c.D, a.b().c.D):
+    pass
diff --git a/python-checks/src/test/resources/checks/duplicateBaseClassCompliant.py b/python-checks/src/test/resources/checks/duplicateBaseClassCompliant.py
new file mode 100644
index 0000000000..6af0f2cf22
--- /dev/null
+++ b/python-checks/src/test/resources/checks/duplicateBaseClassCompliant.py
@@ -0,0 +1,32 @@
+class NoBaseClass:
+    pass
+
+class SingleBase(A):
+    pass
+
+class MultipleUnique(A, B, C):
+    pass
+
+class MultipleUniqueQualified(mod.A, mod.B, mod.C):
+    pass
+
+class OnlyMetaclass(metaclass=Meta):
+    pass
+
+class UniqueBasesWithMetaclass(A, B, metaclass=Meta):
+    pass
+
+class GenericSubscript(Generic[T]):
+    pass
+
+class TwoIdenticalSubscripts(Generic[T], Generic[T]):
+    pass
+
+class SubscriptAndName(Generic[T], Base):
+    pass
+
+class TwoCallBases(make_base(), make_base()):
+    pass
+
+class CallQualifiedBase(obj.method().Attr, obj.method().Attr):
+    pass
diff --git a/python-checks/src/test/resources/checks/emptyCollectionMembershipTest.py b/python-checks/src/test/resources/checks/emptyCollectionMembershipTest.py
new file mode 100644
index 0000000000..5ba38d5569
--- /dev/null
+++ b/python-checks/src/test/resources/checks/emptyCollectionMembershipTest.py
@@ -0,0 +1,71 @@
+def empty_literals(x):
+    if x in []: ...  # Noncompliant {{Remove this membership test on an empty collection; it will always be the same value.}}
+    #  ^^^^^^^
+    if x in {}: ...  # Noncompliant
+    #  ^^^^^^^
+    if x in (): ...  # Noncompliant
+    #  ^^^^^^^
+    if x not in []: ...  # Noncompliant
+    #  ^^^^^^^^^^^
+    if x not in {}: ...  # Noncompliant
+    if x not in (): ...  # Noncompliant
+
+
+def empty_constructor_calls(x):
+    if x in set(): ...  # Noncompliant
+    #  ^^^^^^^^^^
+    if x in tuple(): ...  # Noncompliant
+    if x in frozenset(): ...  # Noncompliant
+    if x not in set(): ...  # Noncompliant
+    if x not in tuple(): ...  # Noncompliant
+    if x not in frozenset(): ...  # Noncompliant
+
+
+def outside_conditions(x, values):
+    # The rule fires on any membership test, not only those used as a condition.
+    result = x in []  # Noncompliant
+    flag = x not in set()  # Noncompliant
+    values = [y for y in range(10) if y in ()]  # Noncompliant
+
+
+def compliant_non_empty_literals(x):
+    if x in [1, 2, 3]: ...
+    if x in {"a": 1}: ...
+    if x in {1, 2}: ...
+    if x in (1,): ...
+    if x in (1, 2): ...
+    if x not in [1, 2, 3]: ...
+
+
+def compliant_constructor_calls_with_arguments(x, iterable):
+    if x in set(iterable): ...
+    if x in tuple(iterable): ...
+    if x in frozenset(iterable): ...
+    if x in list(iterable): ...
+    if x in dict(iterable): ...
+
+
+def compliant_list_dict_builtin_calls(x):
+    # list() / dict() are not covered by this rule. Use [] / {} instead.
+    if x in list(): ...
+    if x in dict(): ...
+
+
+def compliant_variables(x, values):
+    if x in values: ...
+    my_list = []
+    if x in my_list: ...  # Empty but through a variable - out of scope here
+
+
+def compliant_unpacking(x, p1, p2):
+    if x in [*p1, *p2]: ...
+    if x in {**p1}: ...
+    if x in {*p1}: ...
+    if x in (*p1,): ...
+
+
+def compliant_shadowed_builtins(x):
+    def set():  # user-defined function, shadows builtin
+        return [1, 2]
+
+    if x in set(): ...  # Not the builtin set
diff --git a/python-checks/src/test/resources/checks/enumerateUnpacking.py b/python-checks/src/test/resources/checks/enumerateUnpacking.py
new file mode 100644
index 0000000000..aacf026157
--- /dev/null
+++ b/python-checks/src/test/resources/checks/enumerateUnpacking.py
@@ -0,0 +1,163 @@
+
+def noncompliant_basic():
+    lst = ['apple', 'banana', 'cherry']
+    for i, _ in enumerate(lst):  # Noncompliant {{Unpack the value from 'enumerate()' directly instead of using an index lookup.}}
+#               ^^^^^^^^^^^^^^
+        print(lst[i])
+#             ^^^^^^< {{Replace this index lookup with the unpacked value.}}
+
+
+def noncompliant_start_zero_keyword():
+    colors = ['red', 'green', 'blue']
+    for i, _ in enumerate(colors, start=0):  # Noncompliant
+#               ^^^^^^^^^^^^^^^^^^^^^^^^^^
+        print(colors[i])
+#             ^^^^^^^^^< {{Replace this index lookup with the unpacked value.}}
+
+
+def noncompliant_rhs_of_augmented_assignment():
+    items = "abcdef"
+    result = ""
+    for ind, _ in enumerate(items):  # Noncompliant
+#                 ^^^^^^^^^^^^^^^^
+        result += items[ind]
+#                 ^^^^^^^^^^< {{Replace this index lookup with the unpacked value.}}
+
+
+def noncompliant_multiple_usages():
+    lst = ['a', 'b', 'c']
+    for i, _ in enumerate(lst):  # Noncompliant
+#               ^^^^^^^^^^^^^^
+        print(lst[i])
+#             ^^^^^^< {{Replace this index lookup with the unpacked value.}}
+        print(lst[i].upper())
+#             ^^^^^^< {{Replace this index lookup with the unpacked value.}}
+
+
+def compliant_proper_unpacking():
+    fruits = ['apple', 'banana', 'cherry']
+    for i, fruit in enumerate(fruits):
+        print(f"Index {i}: {fruit}")
+
+
+def compliant_multiple_iterables():
+    lst = [1, 2, 3]
+    for i in lst, lst:
+        print(i)
+
+
+def compliant_plain_iterable_not_call():
+    pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
+    for i, v in pairs:
+        print(i, v)
+
+
+def compliant_non_enumerate_call():
+    items = [1, 2, 3]
+    others = [4, 5, 6]
+    for i, v in zip(items, others):
+        print(items[i])
+
+
+def compliant_single_loop_variable():
+    items = ['a', 'b', 'c']
+    for item in enumerate(items):
+        print(item)
+
+
+def compliant_tuple_unpacking_first_var():
+    pairs = [(1, 'a'), (2, 'b')]
+    for (a, b), value in enumerate(pairs):
+        print(a, b, value)
+
+
+def compliant_nonzero_start():
+    items = ['a', 'b', 'c']
+    for i, _ in enumerate(items, start=1):
+        print(items[i - 1])
+
+
+def compliant_variable_start():
+    items = ['a', 'b', 'c']
+    n = 0
+    for i, _ in enumerate(items, n):
+        print(items[i])
+
+
+def compliant_no_arguments():
+    for i, _ in enumerate():
+        print(i)
+
+
+def compliant_inline_literal_iterable():
+    for i, _ in enumerate([1, 2, 3]):
+        pass
+
+
+def compliant_undeclared_iterable():
+    for i, _ in enumerate(undeclared_var):
+        print(undeclared_var[i])
+
+
+def compliant_write_assignment():
+    items = ['a', 'b', 'c']
+    for i, item in enumerate(items):
+        items[i] = item.upper()
+
+
+def compliant_mixed_read_and_write():
+    items = ['a', 'b', 'c']
+    for i, _ in enumerate(items):
+        print(items[i])
+        items[i] = items[i].upper()
+
+
+def compliant_write_augmented_assignment():
+    counts = [0, 0, 0]
+    for i, val in enumerate(counts):
+        counts[i] += 1
+
+
+def compliant_write_del():
+    items = ['a', 'b', 'c']
+    for i, item in enumerate(items):
+        if item == 'b':
+            del items[i]
+            break
+
+
+def compliant_different_list():
+    keys = ['x', 'y', 'z']
+    values = [1, 2, 3]
+    for i, key in enumerate(keys):
+        print(values[i])
+
+
+def compliant_different_index_var():
+    lst = ['a', 'b', 'c']
+    j = 0
+    for i, _ in enumerate(lst):
+        print(lst[j])
+
+
+def compliant_modified_index():
+    items = ['a', 'b', 'c']
+    for i, _ in enumerate(items):
+        if i + 1 < len(items):
+            print(items[i + 1])
+
+
+def compliant_multi_index_subscript():
+    import numpy as np
+    matrix = np.array([[1, 2], [3, 4]])
+    items = [10, 20]
+    for i, _ in enumerate(items):
+        print(matrix[i, 0])
+
+
+def compliant_subscript_object_not_name():
+    def get_list():
+        return ['x', 'y', 'z']
+    lst = ['a', 'b', 'c']
+    for i, _ in enumerate(lst):
+        print(get_list()[i])
diff --git a/python-checks/src/test/resources/checks/fastAPIDependencyAnnotated.py b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotated.py
index 7656223d06..63db2e612c 100644
--- a/python-checks/src/test/resources/checks/fastAPIDependencyAnnotated.py
+++ b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotated.py
@@ -231,13 +231,32 @@ def edge_case_subscription_not_annotated():
     def read_items(items: List[int] = Query()):  # Noncompliant
         return {"items": items}
 
-def false_positive_subscription_with_qualified_name():
+def compliant_typing_annotated_dependency():
     import typing
     @app.get("/items/")
-    def read_items(db: typing.Annotated[str, Depends(get_db)] = Depends(get_db)):  # Noncompliant
+    def read_items(db: typing.Annotated[str, Depends(get_db)] = Depends(get_db)):
         return {"db": db}
 
-def false_negative_annotated_with_dependency_detected():
+def compliant_aliased_typing_annotated_dependency():
+    import typing as t
+    @app.get("/items/")
+    def read_items(db: t.Annotated[str, Depends(get_db)] = Depends(get_db)):
+        return {"db": db}
+
+def compliant_aliased_typing_extensions_annotated_dependency():
+    from typing_extensions import Annotated as Ann
+    @app.get("/items/")
+    def read_items(db: Ann[str, Depends(get_db)] = Depends(get_db)):
+        return {"db": db}
+
+def compliant_parenthesized_annotated_dependency():
+    @app.get("/items/")
+    def read_items(db: (Annotated[str, Depends(get_db)]) = Depends(get_db)):
+        return {"db": db}
+
+def compliant_duplicate_old_and_new_syntax():
+    # Even though FastAPI `Depends` is used as default parameter value, 
+    # since also `Annotated` is used for FastAPI, we don't raise.
     @app.get("/items/")
     def read_items(db: Annotated[str, Depends(get_db)] = Depends(get_db)): # Compliant
         return {"db": db}
diff --git a/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicAnnotatedDominant.py b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicAnnotatedDominant.py
new file mode 100644
index 0000000000..dc6e390464
--- /dev/null
+++ b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicAnnotatedDominant.py
@@ -0,0 +1,17 @@
+from typing import Annotated
+from fastapi import Depends, FastAPI, Query
+
+app = FastAPI()
+
+
+def get_db():
+    return "database_connection"
+
+
+@app.get("/items/")
+def read_items(
+    db: Annotated[str, Depends(get_db)],
+    search: Annotated[str | None, Query(max_length=50)] = None,
+    limit: int = Query(10),  # Noncompliant {{Use "Annotated" type hints for FastAPI dependency injection}}
+):
+    return {"db": db, "search": search, "limit": limit}
diff --git a/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicMixedTooSmallSample.py b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicMixedTooSmallSample.py
new file mode 100644
index 0000000000..1a1c9cb7ad
--- /dev/null
+++ b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicMixedTooSmallSample.py
@@ -0,0 +1,16 @@
+from typing import Annotated
+from fastapi import Depends, FastAPI, Query
+
+app = FastAPI()
+
+
+def get_db():
+    return "database_connection"
+
+
+@app.get("/items/")
+def read_items(
+    db: Annotated[str, Depends(get_db)],
+    limit: int = Query(10),  # Noncompliant {{Use "Annotated" type hints for FastAPI dependency injection}}
+):
+    return {"db": db, "limit": limit}
diff --git a/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicOldStyleDominant.py b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicOldStyleDominant.py
new file mode 100644
index 0000000000..adaf75fa46
--- /dev/null
+++ b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicOldStyleDominant.py
@@ -0,0 +1,18 @@
+from typing import Annotated
+from fastapi import Depends, FastAPI, Query
+
+app = FastAPI()
+
+
+def get_db():
+    return "database_connection"
+
+
+@app.get("/items/")
+def read_items(
+    db = Depends(get_db),
+    limit: int = Query(10),
+    page: int = Query(1),
+    search: Annotated[str | None, Query(max_length=50)] = None,
+):
+    return {"db": db, "search": search, "limit": limit, "page": page}
diff --git a/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicTooSmallSample.py b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicTooSmallSample.py
new file mode 100644
index 0000000000..2522c5ee7c
--- /dev/null
+++ b/python-checks/src/test/resources/checks/fastAPIDependencyAnnotatedFileLocalHeuristicTooSmallSample.py
@@ -0,0 +1,15 @@
+from fastapi import Depends, FastAPI
+
+app = FastAPI()
+
+
+def get_db():
+    return "database_connection"
+
+
+@app.get("/items/")
+def read_items(
+    db = Depends(get_db),  # Noncompliant {{Use "Annotated" type hints for FastAPI dependency injection}}
+    session = Depends(get_db),  # Noncompliant
+):
+    return {"db": db, "session": session}
diff --git a/python-checks/src/test/resources/checks/fastAPIHTTPExceptionDocumented.py b/python-checks/src/test/resources/checks/fastAPIHTTPExceptionDocumented.py
index ed889f076a..b6fa40de9d 100644
--- a/python-checks/src/test/resources/checks/fastAPIHTTPExceptionDocumented.py
+++ b/python-checks/src/test/resources/checks/fastAPIHTTPExceptionDocumented.py
@@ -76,6 +76,11 @@ def positional_status_code_argument():
 #         ^^^^^^^^^^^^^
 
 
+@app.get("/overflow-status")
+def positional_status_code_overflow_literal():
+    raise HTTPException(9223372036854775808, detail="not a representable status code")
+
+
 @app.post("/create")
 def post_method_undocumented():
     raise HTTPException(status_code=409, detail="Conflict")  # Noncompliant
diff --git a/python-checks/src/test/resources/checks/fastHashingOrPlainText/fastHashingOrPlainText.py b/python-checks/src/test/resources/checks/fastHashingOrPlainText/fastHashingOrPlainText.py
index 23856e7ecf..a3ed7582f5 100644
--- a/python-checks/src/test/resources/checks/fastHashingOrPlainText/fastHashingOrPlainText.py
+++ b/python-checks/src/test/resources/checks/fastHashingOrPlainText/fastHashingOrPlainText.py
@@ -8,6 +8,7 @@ def non_hashlib():
     scrypt.hash(password, salt, buflen=31)  # Noncompliant
     scrypt.hash(password, salt, buflen=32)
     scrypt.hash(password, salt, N=1 << 12)  # Noncompliant
+    scrypt.hash(password, salt, N=9223372036854775808 << 1)  # Compliant (invalid long: isLessThanExponent handles NFE)
     exp = 7
     scrypt.hash(password, salt, N=1 << exp)  # Noncompliant
     exp_2 = 1 << 3
@@ -368,3 +369,43 @@ def flask_config():
 PASSWORD_HASHERS = [
     "django.contrib.auth.hashers.UnsaltedSHA1PasswordHasher",  # OK outside of settings.py
 ]
+
+
+## Django User Password
+
+def django_user_password_assignment():
+    from django.contrib.auth.models import User
+
+    user = User()
+    user.username = 'john'
+    user.password = 'mysecretpassword'  # Noncompliant {{Use set_password() or create_user() to properly hash passwords.}}
+    user.save()
+
+    # Compliant - using set_password()
+    user2 = User()
+    user2.set_password('mysecretpassword')
+    user2.save()
+
+    # Compliant - setting other attributes
+    user3 = User()
+    user3.username = 'jane'
+    user3.email = 'jane@example.com'
+
+
+def django_user_create():
+    from django.contrib.auth.models import User
+
+    # Using create() with password argument
+    user = User.objects.create(
+        username='john',
+        password='mysecretpassword'  # Noncompliant {{Use set_password() or create_user() to properly hash passwords.}}
+    )
+
+    # Compliant - using create_user()
+    user = User.objects.create_user(
+        username='john',
+        password='mysecretpassword'
+    )
+
+    # Compliant - using create() without password argument
+    user = User.objects.create(username='john')
diff --git a/python-checks/src/test/resources/checks/fastapiPathParameters.py b/python-checks/src/test/resources/checks/fastapiPathParameters.py
index a50e52dd55..d85f3a4dac 100644
--- a/python-checks/src/test/resources/checks/fastapiPathParameters.py
+++ b/python-checks/src/test/resources/checks/fastapiPathParameters.py
@@ -1,4 +1,9 @@
-from fastapi import FastAPI, APIRouter
+import typing
+from fastapi import FastAPI, APIRouter, Depends, Security, Path
+from typing import Annotated
+from pydantic import BaseModel
+from dataclasses import dataclass
+import typing_extensions
 
 app = FastAPI()
 router = APIRouter()
@@ -120,11 +125,11 @@ def compliant_with_converter(item_id: int):
     return {"item_id": item_id}
 
 @app.get("/items/{item_id}")
-def compliant_with_kwargs(**kwargs):
+def no_issue_bailout_with_kwargs(**kwargs):
     return kwargs
 
 @app.get("/items/{item_id}")
-def compliant_with_args_kwargs(*args, **kwargs):
+def no_issue_bailout_with_args_kwargs(*args, **kwargs):
     return {"args": args, "kwargs": kwargs}
 
 @app.get(status_code=200, path="/items/{item_id}")
@@ -167,3 +172,533 @@ def compliant_empty_path():
 @app.get(True)
 def compliant_path_is_not_a_string():
     pass
+
+# --- starlette route syntax ---
+# FastAPI builts upon starlette.
+# It documents support for "path convert" 
+# See https://fastapi.tiangolo.com/tutorial/path-params/?h=convert#path-convertor
+# But starlette supports also other kinds of coverters (int, float, uuid, etc.)
+# See https://starlette.dev/routing/
+
+@app.get("/items/{item_id:int}")
+def noncompliant_path_param_with_int_converter():  # Noncompliant
+    pass
+
+@app.get("/items/{item_id:path}")
+def noncompliant_path_param_with_path_converter():  # Noncompliant
+    pass
+
+@app.get("/items/{item_id : path}")
+def compliant_ignore_invalid_starlette_route_0():
+    pass
+
+@app.get("/items/{ item_id }")
+def compliant_ignore_invalid_starlette_route_1():
+    pass
+
+# --- Depends() path parameter delegation ---
+
+def get_item(item_id: int):
+    return {"item_id": item_id}
+
+def get_item_positional_only(item_id: int, /):
+    return {"item_id": item_id}
+
+@router.get("/items/{item_id}")
+def compliant_depends_default_value(item=Depends(get_item)):
+    return item
+
+@router.get("/items/{item_id}")
+def compliant_depends_positional_only_dependency(item=Depends(get_item_positional_only)):
+    # Theoretically it is also valuable to raise on positional-only parameters
+    # in dependency callables. But let's not do that for now to limit the scope
+    # of our work. And, perhaps not using positional-only parameters can be
+    # an entirely different rule, that is orthogonal to path parameters.
+    return item
+
+@router.get("/items/{item_id}")
+def compliant_depends_dependency_keyword(item=Depends(dependency=get_item)):
+    return item
+
+@app.get("/items/{item_id}")
+def no_issue_bailout_unresolved_dependency(item=Depends(unknown_dependency)):
+    # `unknown_dependency` cannot be resolved. Bail out to avoid FPs.
+    pass
+
+@app.get("/users/{user_id}/items/{item_id}")
+def noncompliant_positional_only_and_missing_bailout(user_id: int, /, item=Depends(unknown_dependency)):  # Noncompliant {{Path parameter "user_id" should not be positional-only.}}
+    # We don't raise for `item_id`. Bail out to avoid FPs.
+    # But `user_id` is positional and this shoudl be raised even though we cannot resolve `unknown_dependency`
+    pass
+
+def dependency_factory():
+    return dep_without_item_id
+
+@app.get("/items/{item_id}")
+def no_issue_bailout_dynamic_dependency(item=Depends(dependency_factory())):
+    # We don't try to analyze the dynamic behavior of `dependency_factory`.
+    # Bail out to avoid FPs.
+    pass
+
+def dependency_marker_factory():
+    return Depends(get_item)
+
+@app.get("/items/{item_id}")
+def no_issue_bailout_dynamic_default_value_dependency(item=dependency_marker_factory()):
+    # The default value may still evaluate to a valid FastAPI dependency marker.
+    # Bail out rather than report a FP.
+    pass
+
+@app.get("/items/{item_id}")
+def compliant_depends_annotated(item: Annotated[dict, Depends(get_item)]):
+    return item
+
+ItemDependency = Annotated[dict, Depends(get_item)]
+
+@app.get("/items/{item_id}")
+def compliant_depends_annotated_type_alias(item: ItemDependency):
+    pass
+
+def get_dependency_annotation():
+  return Annotated[dict, Depends(dep_without_item_id)]
+
+DynamicDependency = get_dependency_annotation()
+
+@app.get("/items/{item_id}")
+def no_issue_bailout_runtime_type_alias(item: DynamicDependency):
+    # Type alias is not. Bail out to avoid FPs.
+    pass
+
+CyclicDependencyA = CyclicDependencyB
+CyclicDependencyB = CyclicDependencyA
+
+@app.get("/items/{item_id}")
+def no_issue_bailout_cyclic_type_alias(item: CyclicDependencyA):
+    pass
+
+@app.get("/items/{item_id}")
+def compliant_depends_annotated_from_typing_extension(item: typing_extensions.Annotated[dict, Depends(get_item)]):
+    return item
+
+@app.get("/users/{user_id}/items/{item_id}")
+def compliant_depends_partial(user_id: int, item=Depends(get_item)):
+    return {"user_id": user_id, "item": item}
+
+async def get_item_async(item_id: int):
+    return {"item_id": item_id}
+
+@router.get("/items/{item_id}")
+def compliant_depends_async_dependency(item=Depends(get_item_async)):
+    return item
+
+def dep_without_item_id(name: str):
+    return name
+
+@app.get("/items/{item_id}")
+def noncompliant_depends_param_not_in_dep(item=Depends(dep_without_item_id)):  # Noncompliant {{Add path parameter "item_id" to the function signature.}}
+    return item
+
+@app.get("/items/{item_id}")
+def compliant_depends_annotated_qualified(item: typing.Annotated[dict, Depends(get_item)]):
+    return item
+
+@app.get("/items/{item_id}")
+def compliant_security_dependency(item=Security(get_item)):
+    # Security works in the same way of Depends.
+    # See https://fastapi.tiangolo.com/reference/dependencies/?h=depends+securi#fastapi.Security
+    pass
+
+# --- Multiple dependencies in Annotated ---
+# Note: FastAPI only documents Annotated with a single Depends(). It is thus an invalid use of FastAPI.
+# ruff bails out in this situation. 
+# We currently just pick the first Depends.
+
+@app.get("/items/{item_id}")
+def compliant_multiple_depends_metadata_union(item: Annotated[dict, Depends(dep_without_item_id), Depends(get_item)]):
+    pass
+
+
+@app.get("/items/{item_id}")
+def noncompliant_multiple_depends_metadata_no_match(item: Annotated[dict, Depends(dep_without_item_id), Depends(dep_without_item_id)]):  # Noncompliant
+    pass
+
+
+# --- Nested/recursive Depends() ---
+
+def get_item_wrapper(item=Depends(get_item)):
+    return item
+
+@router.get("/items/{item_id}")
+def compliant_nested_depends(item=Depends(get_item_wrapper)):
+    return item
+
+def get_item_annotated_wrapper(item: Annotated[dict, Depends(get_item)]):
+    return item
+
+@app.get("/items/{item_id}")
+def compliant_nested_depends_annotated(item=Depends(get_item_annotated_wrapper)):
+    return item
+
+def dep_level2_no_id(name: str):
+    return name
+
+def dep_level1_no_id(x=Depends(dep_level2_no_id)):
+    return x
+
+@app.get("/items/{item_id}")
+def noncompliant_nested_depends_not_covering(item=Depends(dep_level1_no_id)):  # Noncompliant {{Add path parameter "item_id" to the function signature.}}
+    return item
+
+def wrapper(dep=Depends(unknown_dependency)):
+    return dep
+
+
+@app.get("/items/{item_id}")
+def no_issue_bailout_unknown_nested_dependency(item=Depends(wrapper)):
+    # wrapper depends on `unknown_dependency`, which we cannot resolve.
+    # Bail out to avoid FPs.
+    pass
+
+# --- Circular dependency detection (cycle in Depends chain) ---
+# dep_b_circular references dep_a_circular (defined below)
+def dep_b_circular(dep=Depends(dep_a_circular)):
+    return dep
+
+def dep_a_circular(item_id: int, dep=Depends(dep_b_circular)):
+    return item_id
+
+@app.get("/items/{item_id}")
+def compliant_circular_depends(dep=Depends(dep_a_circular)):
+    return dep
+
+# --- QualifiedExpression as Depends argument ---
+class ItemDepsHolder:
+    @staticmethod
+    def get_item(item_id: int):
+        return item_id
+
+@app.get("/items/{item_id}")
+def compliant_qualified_expr_depends(dep=Depends(ItemDepsHolder.get_item)):
+    return dep
+
+# --- Non-Name/non-QualifiedExpression as Depends argument ---
+@app.get("/items/{item_id}")
+def noncompliant_lambda_depends(dep=Depends(lambda: None)):  # Noncompliant {{Add path parameter "item_id" to the function signature.}}
+    return dep
+
+
+@app.get("/items/{item_id}")
+def compliant_lambda_depends_with_path_param(dep=Depends(lambda item_id: item_id)):
+    return dep
+
+@app.get("/items/{item_id}")
+def noncompliant_depends_without_target(dep=Depends()):  # Noncompliant
+    pass
+
+
+# --- Dependencies specified in path operation decorators ---
+# See https://fastapi.tiangolo.com/tutorial/dependencies/dependencies-in-path-operation-decorators/
+
+@app.get("/items/{item_id}", dependencies=[Depends(get_item)])
+def compliant_route_dependency_covers_path_param():
+    pass
+
+
+@app.get("/items/{item_id}", dependencies=[Depends(dep_without_item_id)])
+def noncompliant_route_dependency_does_not_cover_path_param():  # Noncompliant
+    pass
+
+dependencies = [Depends(unknown_dependency)]
+
+@app.get("/items/{item_id}", dependencies=dependencies)
+def no_issue_bailout_route_dependencies_alias_with_unresolved_dependency():
+    pass
+
+
+@app.get("/items/{item_id}", dependencies=unknown_dependencies)
+def no_issue_bailout_unresolved_route_dependencies_argument():
+    pass
+
+
+@app.get("/items/{item_id}", dependencies=get_route_dependencies())
+def no_issue_bailout_dynamic_route_dependencies_argument():
+    pass
+
+
+@app.get("/items/{item_id}", dependencies=[dependency_marker_factory()])
+def no_issue_bailout_dynamic_route_dependency_list_entry():
+    pass
+
+
+@app.get("/items/{item_id}", dependencies=[Depends(unknown_dependency)])
+def no_issue_bailout_dependency_unresolved():
+    pass
+
+
+@app.get("/items/{item_id}", dependencies=[unknown_dependency])
+def no_issue_bailout_unresolved_direct_route_dependency():
+    pass
+
+
+@app.get("/items/{item_id}", dependencies=[*dependencies])
+def no_issue_bailout_on_dependencies_sequence_unpacking():
+    pass
+
+
+@app.get("/items/{item_id}", dependencies=[object()])
+def no_issue_bailout_invalid_route_dependency_list_entry_object():
+    # Not a dependency entry we support. And in this case it's clearly wrong
+    # FastAPI usage. We bail out.
+    pass
+
+@app.get("/items/{item_id}", dependencies=[42])
+def no_issue_bailout_invalid_route_dependency_list_entry_integer():
+    # Not a dependency entry we support. And in this case it's clearly  wrong
+    # FastAPI usage. We bail out.
+    pass
+
+
+# --- Dependencies specified in FastAPI/APIRouter constructors ---
+# See https://fastapi.tiangolo.com/tutorial/dependencies/global-dependencies/
+
+router_with_dependency = APIRouter(dependencies=[Depends(get_item)])
+
+@router_with_dependency.get("/items/{item_id}")
+def compliant_router_dependency_covers_path_param():
+    pass
+
+
+router_without_path_dependency = APIRouter(dependencies=[Depends(dep_without_item_id)])
+
+@router_without_path_dependency.get("/items/{item_id}")
+def noncompliant_router_dependency_does_not_cover_path_param():  # Noncompliant
+    pass
+
+
+app_with_dependency = FastAPI(dependencies=[Depends(get_item)])
+
+@app_with_dependency.get("/items/{item_id}")
+def compliant_app_dependency_covers_path_param():
+    pass
+
+
+FastAPIAlias = FastAPI
+app_with_aliased_fastapi_dependency = FastAPIAlias(dependencies=[Depends(get_item)])
+
+@app_with_aliased_fastapi_dependency.get("/items/{item_id}")
+def compliant_aliased_app_dependency_covers_path_param():
+    pass
+
+
+# --- Path aliases ---
+# See docs on `alias` param at https://fastapi.tiangolo.com/reference/parameters/?h=Path+reference#fastapi.Path
+
+@app.get("/items/{item-id}")
+def compliant_literal_path_alias(item_id: Annotated[int, Path(alias="item-id")]):
+    pass
+
+
+@app.get("/items/{item_id}")
+def noncompliant_path_alias_replaces_parameter_name(item_id: Annotated[int, Path(alias="other_id")]):  # Noncompliant {{Add path parameter "item_id" to the function signature.}}
+    pass
+
+
+@app.get("/items/{item-id}")
+def compliant_default_value_path_alias(item_id: int = Path(alias="item-id")):
+    pass
+
+
+@app.get("/items/{item_id}")
+def compliant_default_value_path_without_alias(item_id: int = Path()):
+    pass
+
+
+@app.get("/items/{item_id}")
+def noncompliant_default_value_path_without_alias(other_id: int = Path()):  # Noncompliant
+    pass
+
+ITEM_ID_ALIAS = "item-id"
+
+@app.get("/items/{item-id}")
+def compliant_constant_path_alias(item_id: Annotated[int, Path(alias=ITEM_ID_ALIAS)]):
+    pass
+
+
+@app.get("/items/{item-id}")
+def no_issue_bailout_unknown_path_alias(item_id: Annotated[int, Path(alias=get_alias_unresolved())]):
+    pass
+
+
+@app.get("/items/{item-id}")
+def no_issue_bailout_unknown_default_value_path_alias(item_id: int = Path(alias=get_alias_unresolved())):
+    pass
+
+
+def get_item_with_alias(item_id: Annotated[int, Path(alias="item-id")]):
+    return item_id
+
+
+@app.get("/items/{item-id}")
+def compliant_dependency_has_path_alias(item=Depends(get_item_with_alias)):
+    pass
+
+
+def get_item_with_default_alias(item_id: int = Path(alias="item-id")):
+    return item_id
+
+
+@app.get("/items/{item-id}")
+def compliant_dependency_default_value_path_alias(item=Depends(get_item_with_default_alias)):
+    pass
+
+# --- Class dependencies ---
+# --- Callable dependency instances ---
+# See https://fastapi.tiangolo.com/tutorial/dependencies/classes-as-dependencies/
+
+class ItemQuery:
+    def __init__(self, item_id: int):
+        pass
+
+
+@app.get("/items/{item_id}")
+def compliant_class_dependency(query: Annotated[ItemQuery, Depends(ItemQuery)]):
+    pass
+
+
+@app.get("/items/{item_id}")
+def compliant_class_dependency_default_value(query: ItemQuery = Depends(ItemQuery)):
+    pass
+
+
+class EmptyItemQuery:
+    pass
+
+
+@app.get("/items/{item_id}")
+def noncompliant_class_dependency_without_path_param_in_init(query: Annotated[EmptyItemQuery, Depends(EmptyItemQuery)]):  # Noncompliant
+    pass
+
+
+class PydanticItemQueryWithoutPathParam(BaseModel):
+    name: str
+
+
+@app.get("/items/{item_id}")
+def no_issue_bailout_pydantic_dependency(query: Annotated[PydanticItemQueryWithoutPathParam, Depends(PydanticItemQueryWithoutPathParam)]):
+    pass
+
+
+@dataclass
+class DataclassItemQueryWithoutPathParam:
+    name: str
+
+
+@app.get("/items/{item_id}")
+def no_issue_bailout_dataclass_dependency(query: Annotated[DataclassItemQueryWithoutPathParam, Depends(DataclassItemQueryWithoutPathParam)]):
+    pass
+
+
+def generated_constructor(cls):
+    return cls
+
+
+@generated_constructor
+class DecoratedItemQuery:
+    item_id: int
+
+
+@app.get("/items/{item_id}")
+def no_issue_bailout_decorated_class_without_explicit_init(query: Annotated[DecoratedItemQuery, Depends(DecoratedItemQuery)]):
+    pass
+
+
+class ItemChecker:
+    def __call__(self, item_id: int):
+        return item_id
+
+
+checker = ItemChecker()
+
+
+@app.get("/items/{item_id}")
+def compliant_callable_instance_dependency(item=Depends(checker)):
+    pass
+
+
+@app.get("/items/{item_id}")
+def compliant_callable_constructor_instance_dependency(item=Depends(ItemChecker())):
+    pass
+
+
+class DependencyWithoutCall:
+    pass
+
+
+dependency_without_call = DependencyWithoutCall()
+
+
+@app.get("/items/{item_id}")
+def noncompliant_dependency_instance_without_call(item=Depends(dependency_without_call)):  # Noncompliant {{Add path parameter "item_id" to the function signature.}}
+    pass
+
+
+class InheritedCallableDependency(ItemChecker):
+    pass
+
+
+inherited_callable_dependency = InheritedCallableDependency()
+
+
+@app.get("/items/{other_id}")
+def no_issue_bailout_inherited_callable_dependency(item=Depends(inherited_callable_dependency)):
+    pass
+
+
+class ItemCheckerClassReference:
+    def __call__(self, item_id: int):
+        return item_id
+
+
+@app.get("/items/{item_id}")
+def noncompliant_class_dependency_without_init_path_param(item=Depends(ItemCheckerClassReference)):  # Noncompliant {{Add path parameter "item_id" to the function signature.}}
+    # FastAPI inspects __init__ when Depends receives a class, not the __call__ method used by instances.
+    pass
+
+
+# --- Shortcut when class callable is used as dependency ---
+# See https://fastapi.tiangolo.com/tutorial/dependencies/classes-as-dependencies/?h=shortcut#type-annotation-vs-depends
+
+@app.get("/items/{item_id}")
+def compliant_depends_shortcut_annotated(query: Annotated[ItemQuery, Depends()]):
+    pass
+
+
+@app.get("/items/{item_id}")
+def compliant_depends_shortcut_default(query: ItemQuery = Depends()):
+    pass
+
+
+# --- Known FPs: include_router(..., dependencies=...) is currently out of scope ---
+
+def require_item_access(item_id: int):
+    return item_id
+
+router_included_with_dependency = APIRouter()
+@router_included_with_dependency.get("/items/{item_id}")
+def known_fp_app_include_router_dependency():  # Noncompliant
+    # Known FP: `app.include_router(..., dependencies=[Depends(require_item_access)])`
+    # covers `item_id`, but include_router dependencies are currently not modeled by this rule.
+    pass
+
+app_with_include_router_dependency = FastAPI()
+app_with_include_router_dependency.include_router(router_included_with_dependency, dependencies=[Depends(require_item_access)])
+
+parent_router_with_include_router_dependency = APIRouter()
+child_router_included_with_dependency = APIRouter()
+parent_router_with_include_router_dependency.include_router(child_router_included_with_dependency, dependencies=[Depends(require_item_access)])
+
+@child_router_included_with_dependency.get("/items/{item_id}/issues")
+def known_fp_router_include_router_dependency():  # Noncompliant
+    # Known FP: `parent_router.include_router(..., dependencies=[Depends(require_item_access)])`
+    # covers `item_id`, but nested include_router dependencies are currently not modeled by this rule.
+    pass
diff --git a/python-checks/src/test/resources/checks/flaskHardCodedJWTSecretKey.py b/python-checks/src/test/resources/checks/flaskHardCodedJWTSecretKey.py
index 15a6bbf0fd..89b419607f 100644
--- a/python-checks/src/test/resources/checks/flaskHardCodedJWTSecretKey.py
+++ b/python-checks/src/test/resources/checks/flaskHardCodedJWTSecretKey.py
@@ -1,36 +1,36 @@
 from flask import Flask, current_app
 def test_non_compliant_assignment_expressions(x):
     app = Flask(__name__)
-    assigned_secret = 'hardcoded_secret'
+    assigned_secret = 'Azerty123'
 
     # Tests for "flask.app.Flask.config"
-    app.config['JWT_SECRET_KEY'] = 'secret'  # Noncompliant {{Don't disclose "Flask" JWT secret keys.}}
+    app.config['JWT_SECRET_KEY'] = 'Azerty123'  # Noncompliant {{Don't disclose "Flask" JWT secret keys.}}
 #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^>                           {{Assignment to sensitive property.}}
-#                                  ^^^^^^^^@-1
+#                                  ^^^^^^^^^^^@-1
     app.config['JWT_SECRET_KEY'] = assigned_secret  # Noncompliant
 #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^^^^^
-    _ = app.config['JWT_SECRET_KEY'] = 'secret'  # Noncompliant
-#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^
+    _ = app.config['JWT_SECRET_KEY'] = 'Azerty123'  # Noncompliant
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^
 
     #   False negatives.
-    app.config['JWT_SECRET_KEY'], _ = 'secret', x # FN: Should be extended to ExpressionList in the lhs containing more than one expression
-    app.config['JWT_SECRET_KEY'], _ = _, app.config['JWT_SECRET_KEY'] = 'secret', x # FN: Same as above
+    app.config['JWT_SECRET_KEY'], _ = 'Azerty123', x # FN: Should be extended to ExpressionList in the lhs containing more than one expression
+    app.config['JWT_SECRET_KEY'], _ = _, app.config['JWT_SECRET_KEY'] = 'Azerty123', x # FN: Same as above
 
 
     # Tests for "flask.globals.current_app.config"
-    current_app.config['JWT_SECRET_KEY'] = 'secret'  # Noncompliant {{Don't disclose "Flask" JWT secret keys.}}
+    current_app.config['JWT_SECRET_KEY'] = 'Azerty123'  # Noncompliant {{Don't disclose "Flask" JWT secret keys.}}
 #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^>                           {{Assignment to sensitive property.}}
-#                                          ^^^^^^^^@-1
+#                                          ^^^^^^^^^^^@-1
     current_app.config['JWT_SECRET_KEY'] = assigned_secret  # Noncompliant
-    _ = current_app.config['JWT_SECRET_KEY'] = 'secret'  # Noncompliant
+    _ = current_app.config['JWT_SECRET_KEY'] = 'Azerty123'  # Noncompliant
 
     #   False negatives.
-    current_app.config['JWT_SECRET_KEY'], _ = 'mysecret', x # FN
-    current_app.config['JWT_SECRET_KEY'], _ = _, current_app.config['JWT_SECRET_KEY'] = 'secret', x # FN
+    current_app.config['JWT_SECRET_KEY'], _ = 'Azerty123', x # FN
+    current_app.config['JWT_SECRET_KEY'], _ = _, current_app.config['JWT_SECRET_KEY'] = 'Azerty123', x # FN
 
 
-    current_app.config['JWT_SECRET_KEY'] = app.config['JWT_SECRET_KEY'] = 'secret'      # Noncompliant
-#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^
+    current_app.config['JWT_SECRET_KEY'] = app.config['JWT_SECRET_KEY'] = 'Azerty123'      # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^
 
 
 
diff --git a/python-checks/src/test/resources/checks/flaskHardCodedSecretKey.py b/python-checks/src/test/resources/checks/flaskHardCodedSecretKey.py
index 48a75fab6e..f2a4792cdd 100644
--- a/python-checks/src/test/resources/checks/flaskHardCodedSecretKey.py
+++ b/python-checks/src/test/resources/checks/flaskHardCodedSecretKey.py
@@ -1,59 +1,59 @@
 from flask import Flask, current_app
 def test_non_compliant_assignment_expressions(x):
     app = Flask(__name__)
-    assigned_secret = 'hardcoded_secret'
+    assigned_secret = 'Azerty123'
 
     # Tests for "flask.app.Flask.config"
-    app.config['SECRET_KEY'] = 'secret'  # Noncompliant {{Don't disclose "Flask" secret keys.}}
+    app.config['SECRET_KEY'] = 'Azerty123'  # Noncompliant {{Don't disclose "Flask" secret keys.}}
 #   ^^^^^^^^^^^^^^^^^^^^^^^^>                           {{Assignment to sensitive property.}}
-#                              ^^^^^^^^@-1
+#                              ^^^^^^^^^^^@-1
     app.config['SECRET_KEY'] = assigned_secret  # Noncompliant
 #   ^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^^^^^
-    _ = app.config['SECRET_KEY'] = 'secret'  # Noncompliant
-#       ^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^
+    _ = app.config['SECRET_KEY'] = 'Azerty123'  # Noncompliant
+#       ^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^
 
     #   False negatives.
-    app.config['SECRET_KEY'], _ = 'secret', x # FN: Should be extended to ExpressionList in the lhs containing more than one expression
-    app.config['SECRET_KEY'], _ = _, app.config['SECRET_KEY'] = 'secret', x # FN: Same as above
+    app.config['SECRET_KEY'], _ = 'Azerty123', x # FN: Should be extended to ExpressionList in the lhs containing more than one expression
+    app.config['SECRET_KEY'], _ = _, app.config['SECRET_KEY'] = 'Azerty123', x # FN: Same as above
 
 
     # Tests for "flask.app.Flask.secret_key"
-    app.secret_key = 'secret'         # Noncompliant {{Don't disclose "Flask" secret keys.}}
+    app.secret_key = 'Azerty123'         # Noncompliant {{Don't disclose "Flask" secret keys.}}
 #   ^^^^^^^^^^^^^^>                                    {{Assignment to sensitive property.}}
-#                    ^^^^^^^^@-1
+#                    ^^^^^^^^^^^@-1
     app.secret_key = assigned_secret  # Noncompliant
-    _ = app.secret_key = 'mysecret'  # Noncompliant
+    _ = app.secret_key = 'Azerty123'  # Noncompliant
 
     #   False negatives.
-    app.secret_key, _ = 'secret', x # FN: Should be extended to ExpressionList in the lhs containing more than one expression
-    app.secret_key, _ = _, app.secret_key = 'secret', x # FN: Same as above
+    app.secret_key, _ = 'Azerty123', x # FN: Should be extended to ExpressionList in the lhs containing more than one expression
+    app.secret_key, _ = _, app.secret_key = 'Azerty123', x # FN: Same as above
 
 
     # Tests for "flask.globals.current_app.config"
-    current_app.config['SECRET_KEY'] = 'secret'  # Noncompliant {{Don't disclose "Flask" secret keys.}}
+    current_app.config['SECRET_KEY'] = 'Azerty123'  # Noncompliant {{Don't disclose "Flask" secret keys.}}
 #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^>                                    {{Assignment to sensitive property.}}
-#                                      ^^^^^^^^@-1
+#                                      ^^^^^^^^^^^@-1
     current_app.config['SECRET_KEY'] = assigned_secret  # Noncompliant
-    _ = current_app.config['SECRET_KEY'] = 'secret'  # Noncompliant
+    _ = current_app.config['SECRET_KEY'] = 'Azerty123'  # Noncompliant
 
     #    False negatives.
-    current_app.config['SECRET_KEY'], _ = 'mysecret', x # FN
-    current_app.config['SECRET_KEY'], _ = _, current_app.config['SECRET_KEY'] = 'secret', x # FN
+    current_app.config['SECRET_KEY'], _ = 'Azerty123', x # FN
+    current_app.config['SECRET_KEY'], _ = _, current_app.config['SECRET_KEY'] = 'Azerty123', x # FN
 
 
     # Tests for "flask.globals.current_app.secret_key"
-    current_app.secret_key = 'secret'   # Noncompliant {{Don't disclose "Flask" secret keys.}}
+    current_app.secret_key = 'Azerty123'   # Noncompliant {{Don't disclose "Flask" secret keys.}}
 #   ^^^^^^^^^^^^^^^^^^^^^^>                            {{Assignment to sensitive property.}}
-#                            ^^^^^^^^@-1
+#                            ^^^^^^^^^^^@-1
     current_app.secret_key = assigned_secret  # Noncompliant
-    _ = current_app.secret_key = 'mysecret'  # Noncompliant
+    _ = current_app.secret_key = 'Azerty123'  # Noncompliant
 
     #   False negatives.
     current_app.secret_key, _ = assigned_secret, x # FN
-    current_app.secret_key, _ = _, current_app.secret_key = 'secret', x # FN
+    current_app.secret_key, _ = _, current_app.secret_key = 'Azerty123', x # FN
 
-    current_app.config['SECRET_KEY'] = app.config['SECRET_KEY'] = 'secret'      # Noncompliant
-#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^
+    current_app.config['SECRET_KEY'] = app.config['SECRET_KEY'] = 'Azerty123'      # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^^^^^^^^^^^^^^>  ^^^^^^^^^^^
     some_secret = assigned_secret
     some_secret1 = some_secret
     some_secret2 = some_secret1
diff --git a/python-checks/src/test/resources/checks/generated/cognitiveComplexity_pb2_test.py b/python-checks/src/test/resources/checks/generated/cognitiveComplexity_pb2_test.py
new file mode 100644
index 0000000000..bc774913d5
--- /dev/null
+++ b/python-checks/src/test/resources/checks/generated/cognitiveComplexity_pb2_test.py
@@ -0,0 +1,10 @@
+def serialize_user(value):  # Noncompliant {{Refactor this function to reduce its Cognitive Complexity from 8 to the 0 allowed.}}
+    if value is None:
+        return None
+    if value.name == "default":
+        if value.email == "default":
+            return "default generated value"
+        if value.phone == "default":
+            return "default generated value"
+        if value.address == "default":
+            return "default generated value"
diff --git a/python-checks/src/test/resources/checks/generated/commentedCode_pb2_test.py b/python-checks/src/test/resources/checks/generated/commentedCode_pb2_test.py
new file mode 100644
index 0000000000..53fe3fc49b
--- /dev/null
+++ b/python-checks/src/test/resources/checks/generated/commentedCode_pb2_test.py
@@ -0,0 +1,8 @@
+# if legacy_users:
+#     migrate_users()
+
+# Noncompliant@-3 {{Remove this commented out code.}}
+
+
+def serialize_user(value):
+    return value
diff --git a/python-checks/src/test/resources/checks/generated/stringLiteralDuplication_pb2_test.py b/python-checks/src/test/resources/checks/generated/stringLiteralDuplication_pb2_test.py
new file mode 100644
index 0000000000..ad8ff1be13
--- /dev/null
+++ b/python-checks/src/test/resources/checks/generated/stringLiteralDuplication_pb2_test.py
@@ -0,0 +1,6 @@
+def serialize_user(value):
+    if value.name == "default":
+        return "default generated value"  # Noncompliant {{Define a constant instead of duplicating this literal "default generated value" 3 times.}}
+    if value.email == "default":
+        return "default generated value"
+    return "default generated value"
diff --git a/python-checks/src/test/resources/checks/generated/user_pb2.py b/python-checks/src/test/resources/checks/generated/user_pb2.py
new file mode 100644
index 0000000000..f16fcc99ef
--- /dev/null
+++ b/python-checks/src/test/resources/checks/generated/user_pb2.py
@@ -0,0 +1,19 @@
+# Generated by the protocol buffer compiler.
+# if legacy_users:
+#     migrate_users()
+"""if legacy_users:
+    migrate_users()
+"""
+
+
+def serialize_user(value):
+    if value is None:
+        return None
+    if value.name == "default":
+        if value.email == "default":
+            return "default generated value"
+        if value.phone == "default":
+            return "default generated value"
+        if value.address == "default":
+            return "default generated value"
+    return "default generated value"
diff --git a/python-checks/src/test/resources/checks/generated/user_pb2_grpc.py b/python-checks/src/test/resources/checks/generated/user_pb2_grpc.py
new file mode 100644
index 0000000000..5e9eb483ee
--- /dev/null
+++ b/python-checks/src/test/resources/checks/generated/user_pb2_grpc.py
@@ -0,0 +1,19 @@
+# Generated by the protocol buffer compiler.
+# if legacy_users:
+#     migrate_users()
+"""if legacy_users:
+    migrate_users()
+"""
+
+
+def add_UserServicer_to_server(servicer, server):
+    if servicer is None:
+        return None
+    if server is None:
+        return None
+    if server.started:
+        if servicer.active:
+            return "default generated value"
+        if servicer.ready:
+            return "default generated value"
+    return "default generated value"
diff --git a/python-checks/src/test/resources/checks/genericException/genericExceptionRaised.py b/python-checks/src/test/resources/checks/genericException/genericExceptionRaised.py
index fe78defa4c..73295530ff 100644
--- a/python-checks/src/test/resources/checks/genericException/genericExceptionRaised.py
+++ b/python-checks/src/test/resources/checks/genericException/genericExceptionRaised.py
@@ -48,3 +48,23 @@ def python2_multiple_expressions(cond):
 
 def no_issue_with_self_return_type():
     raise MyException().with_traceback("foo")
+
+def raised_exception_is_the_parameter(exception: BaseException):
+    raise exception
+
+global_exception = BaseException()
+def raise_global_exception():
+    raise global_exception
+
+def handle_exception(e: Exception):
+    raise e
+
+def intermediate_handle_exception(e: Exception):
+    handle_exception(e)
+
+def constructed_exceptions_passed_to_handle_exception_raise():
+    handle_exception(Exception()) # Noncompliant
+    handle_exception(BaseException()) # Noncompliant
+
+def is_instance_do_not_raise(e):
+    isInstance(e, Exception)
diff --git a/python-checks/src/test/resources/checks/genericTypeStatement.py b/python-checks/src/test/resources/checks/genericTypeStatement.py
index 2f756a01df..20ecc1b318 100644
--- a/python-checks/src/test/resources/checks/genericTypeStatement.py
+++ b/python-checks/src/test/resources/checks/genericTypeStatement.py
@@ -20,13 +20,11 @@ def non_compliant_1():
     type MyAlias[T] = dict[T, _R]  # Noncompliant
     #    ^^^^^^^              ^^<    {{Use of "TypeVar" here.}}
 
-    M = TypeVar("M")
-    #   ^^^^^^^^^^^^>           {{"TypeVar" is assigned here.}}
-    type MyAlias[M] = set[M]  # Noncompliant
-    #    ^^^^^^^          ^<    {{Use of "TypeVar" here.}}
 
 
 def compliant(AType):
     type MyAlias[T] = dict[T, str]
     type MyAlias = set[str]
     type MyAlias = set[AType]
+    M = TypeVar("M")
+    type MyAlias[M] = set[M]  # Compliant: M in set[M] refers to the type parameter, not the TypeVar
diff --git a/python-checks/src/test/resources/checks/graphQLDenialOfService.py b/python-checks/src/test/resources/checks/graphQLDenialOfService.py
index 4d373825e2..3bc4e831d9 100644
--- a/python-checks/src/test/resources/checks/graphQLDenialOfService.py
+++ b/python-checks/src/test/resources/checks/graphQLDenialOfService.py
@@ -47,6 +47,14 @@ def non_compliant():
         )
     )
 
+    app.add_url_rule("/api",
+        view_func=GraphQLView.as_view(  # Noncompliant
+            name="api",
+            schema=schema,
+            middleware={UnknownMiddleware}
+        )
+    )
+
     app.add_url_rule("/api",
         view_func=GraphQLView.as_view()  # Noncompliant
     )
@@ -121,3 +129,21 @@ def compliant():
         schema=schema,
         validation_rules=some_middleware, # if it is not a list or a tuple we should not raise an issue
     )
+
+    app.add_url_rule(
+        '/compliant/graphql',
+        view_func=GraphQLView.as_view( # Compliant
+            'compliant',
+            schema=schema,
+            middleware={DepthProtectionMiddleware}  # Safe middleware, set literal
+        )
+    )
+
+    app.add_url_rule(
+        '/compliant/graphql',
+        view_func=GraphQLView.as_view( # Compliant
+            'compliant',
+            schema=schema,
+            validation_rules={DepthLimitValidator}   # Safe validation rules, set literal
+        )
+    )
diff --git a/python-checks/src/test/resources/checks/groupByIteratorReuse.py b/python-checks/src/test/resources/checks/groupByIteratorReuse.py
new file mode 100644
index 0000000000..2b2b5ba562
--- /dev/null
+++ b/python-checks/src/test/resources/checks/groupByIteratorReuse.py
@@ -0,0 +1,210 @@
+from itertools import groupby
+
+
+def noncompliant_assigned_to_dict_subscript():
+    data = [1, 1, 2, 2, 3]
+    groups = {}
+    for key, group in groupby(data):
+        groups[key] = group  # Noncompliant {{Consume this group iterator inside the loop, or materialize it into a collection.}}
+#                     ^^^^^
+
+
+def noncompliant_yielded():
+    data = [1, 1, 2, 2, 3]
+    for key, group in groupby(data):
+        yield group  # Noncompliant
+
+
+def noncompliant_inside_lambda_captured_by_outer_storage():
+    data = [1, 1, 2, 2, 3]
+    fns = []
+    for key, group in groupby(data):
+        fns.append(lambda: list(group))  # Noncompliant
+#                               ^^^^^
+
+
+def noncompliant_chain_top_lands_at_sink():
+    data = [1, 1, 2, 2, 3]
+    for key, group in groupby(data):
+        it = enumerate(group)  # Noncompliant
+
+
+def noncompliant_set_add():
+    data = [1, 1, 2, 2, 3]
+    seen = set()
+    for key, group in groupby(data):
+        seen.add(group)  # Noncompliant
+
+
+def noncompliant_dict_setdefault():
+    data = [1, 1, 2, 2, 3]
+    cache = {}
+    for key, group in groupby(data):
+        cache.setdefault(key, group)  # Noncompliant
+
+
+def noncompliant_lazy_passthrough_to_storing_method():
+    from operator import itemgetter
+    data = [(1, "a"), (1, "b"), (2, "c")]
+    out = []
+    for key, group in groupby(data):
+        out.append(map(itemgetter(0), group))  # Noncompliant
+
+
+def noncompliant_groupby_alias():
+    from itertools import groupby as gb
+    data = [1, 1, 2, 2, 3]
+    groups = {}
+    for key, group in gb(data):
+        groups[key] = group  # Noncompliant
+
+
+def compliant_immediate_list():
+    data = [1, 1, 2, 2, 3]
+    groups = {}
+    for key, group in groupby(data):
+        groups[key] = list(group)
+
+
+def compliant_str_join():
+    data = ["a", "a", "b"]
+    for key, group in groupby(data):
+        joined = ",".join(group)
+
+
+def compliant_group_passed_to_runtime_class_object():
+    data = [1, 1, 2, 2, 3]
+    container_class = type([])
+    for key, group in groupby(data):
+        container = container_class(group)
+
+
+def compliant_for_loop_iterable():
+    data = [1, 1, 2, 2, 3]
+    for key, group in groupby(data):
+        for item in group:
+            print(item)
+
+
+def compliant_outer_group_consumed_by_nested_groupby():
+    data = [(1, "a"), (1, "b"), (2, "c")]
+    for key, group in groupby(data):
+        for subkey, subgroup in groupby(group):
+            print(subkey, list(subgroup))
+
+
+def compliant_print():
+    data = [1, 1, 2, 2, 3]
+    for key, group in groupby(data):
+        print(group)
+
+
+def compliant_lazy_passthrough_consumed_by_outer_safe_consumer_map():
+    from operator import itemgetter
+    data = [(1, "a"), (1, "b"), (2, "c")]
+    for key, group in groupby(data):
+        keys = list(map(itemgetter(0), group))
+
+
+def compliant_group_as_keyword_arg():
+    data = [1, 1, 2, 2, 3]
+    for key, group in groupby(data):
+        result = list(iterable=group)
+
+
+def compliant_extended_into_list():
+    data = [1, 1, 2, 2, 3]
+    out = []
+    for key, group in groupby(data):
+        out.extend(group)
+
+
+def compliant_dict_updated_with_group():
+    data = [(1, "a"), (1, "b"), (2, "c")]
+    mapping = {}
+    for key, group in groupby(data):
+        mapping.update(group)
+
+
+def compliant_returned():
+    data = [1, 1, 2, 2, 3]
+    for key, group in groupby(data):
+        return group
+
+
+def compliant_group_rebound_in_loop_body():
+    data = [1, 1, 2, 2, 3]
+    for key, group in groupby(data):
+        group = list(group)
+        print(group)
+
+
+def compliant_multiple_iterables():
+    data1 = [1, 1, 2]
+    data2 = [3, 3, 4]
+    for key, group in groupby(data1), groupby(data2):
+        saved = group
+
+
+def compliant_tuple_pattern_loop_var():
+    data = [(1, "a"), (1, "b"), (2, "c")]
+    for key, (a, b) in groupby(data):
+        saved = a
+
+
+def compliant_single_loop_variable():
+    data = [(1, 2), (1, 3)]
+    for pair in groupby(data):
+        saved = pair
+
+
+def compliant_not_a_call():
+    data = [(1, [10, 11]), (2, [20, 21])]
+    groups = {}
+    for key, group in data:
+        groups[key] = group
+
+
+def compliant_non_groupby_call():
+    def my_groupby(data):
+        return iter([])
+
+    data = [1, 1, 2, 2, 3]
+    groups = {}
+    for key, group in my_groupby(data):
+        groups[key] = group
+
+
+def fn_unresolved_callee():  # FN: unresolved callee assumed safe to avoid false positives
+    from nonexistent_module import safe_consumer
+    data = [1, 1, 2, 2, 3]
+    for key, group in groupby(data):
+        result = safe_consumer(group)
+
+
+def fn_groupby_in_dict_comprehension():  # FN: check only handles FOR_STMT
+    data = [1, 1, 2, 2, 3]
+    groups = {k: g for k, g in groupby(data)}
+
+
+def fn_in_container_literal():  # FN: container-literal sinks are not analyzed
+    data = [1, 1, 2, 2, 3]
+    for key, group in groupby(data):
+        return [group]
+
+
+def fn_in_else_clause():  # FN: only the for-statement body is analyzed
+    data = [1, 1, 2, 2, 3]
+    saved = None
+    for key, group in groupby(data):
+        pass
+    else:
+        saved = group
+
+
+def fn_with_any_rebinding():  # FN: any rebinding of `group` in the body causes us to skip the loop
+    data = [1, 1, 2, 2, 3]
+    groups = {}
+    for key, group in groupby(data):
+        groups[key] = group
+        group = list(group)
diff --git a/python-checks/src/test/resources/checks/groupByIteratorReuseMultipleReads.py b/python-checks/src/test/resources/checks/groupByIteratorReuseMultipleReads.py
new file mode 100644
index 0000000000..10333a26d6
--- /dev/null
+++ b/python-checks/src/test/resources/checks/groupByIteratorReuseMultipleReads.py
@@ -0,0 +1,14 @@
+from itertools import groupby
+
+# Used by GroupByIteratorReuseCheckTest.no_quick_fix_when_multiple_reads_in_loop_body
+# Asserts every unsafe read is reported and none get a quickfix (it would exhaust the iterator
+# before the remaining reads execute).
+
+data = [1, 1, 2, 2, 3]
+first = []
+second = []
+third = []
+for key, group in groupby(data):
+    first.append(group)   # Noncompliant
+    second.append(group)  # Noncompliant
+    third.append(group)   # Noncompliant
diff --git a/python-checks/src/test/resources/checks/groupByIteratorReuseUnsafeWithSafeLaterRead.py b/python-checks/src/test/resources/checks/groupByIteratorReuseUnsafeWithSafeLaterRead.py
new file mode 100644
index 0000000000..39f23a2add
--- /dev/null
+++ b/python-checks/src/test/resources/checks/groupByIteratorReuseUnsafeWithSafeLaterRead.py
@@ -0,0 +1,12 @@
+from itertools import groupby
+
+# Used by GroupByIteratorReuseCheckTest.no_quick_fix_when_safe_read_follows_unsafe_one
+# Wrapping the unsafe read in list() would exhaust the iterator and silently break
+# the subsequent `for item in group:` loop, so no quickfix should be attached.
+
+data = [1, 1, 2, 2, 3]
+groups = {}
+for key, group in groupby(data):
+    groups[key] = group  # Noncompliant
+    for item in group:
+        print(item)
diff --git a/python-checks/src/test/resources/checks/hardCodedCredentials.py b/python-checks/src/test/resources/checks/hardCodedCredentials.py
index 605b04a610..a99b2d451c 100644
--- a/python-checks/src/test/resources/checks/hardCodedCredentials.py
+++ b/python-checks/src/test/resources/checks/hardCodedCredentials.py
@@ -44,6 +44,8 @@ def __init__(self):
         self.passed = "passed"
         fieldNameWithPasswordInIt = "azerty123"            # Noncompliant {{"password" detected here, review this potentially hard-coded credential.}}
         fieldNameWithPasswordInIt = os.getenv("password", "")  # OK
+        fieldNameWithPasswordInIt = os.getenv("password", "Azerty123")  # Noncompliant
+        fieldNameWithPasswordInIt = os.environ.get("password", "Azerty123")  # Noncompliant
         self.fieldNameWithPasswordInIt = "azerty123"            # Noncompliant {{"password" detected here, review this potentially hard-coded credential.}}
         self.fieldNameWithPasswordInIt = os.getenv("password", "")  # OK
 
@@ -85,7 +87,7 @@ def a(self,pwd="azerty123", other=None):  # Noncompliant {{"pwd" detected here,
         password = u'azerty123'                                   # Noncompliant
         password = f"azerty123"                                   # Noncompliant
         password = b"azerty123"                                   # Noncompliant
-        password = "?"                                            # Noncompliant
+        password = "Xk28vQ91"                                     # Noncompliant
         variableNameWithPasswordInIt = 'azerty123'                # Noncompliant
         variableNameWithPassphraseInIt = 'azerty123'              # Noncompliant
         variableNameWithPasswdInIt ='azerty123'                   # Noncompliant
@@ -137,10 +139,10 @@ def db(self, pwd):
         mysql.connector.connection.MySQLConnection(host='localhost', user='root', "")  # OK
 
         pymysql.connect(host='localhost', user='root', password='Azerty123') # Noncompliant
-        pymysql.connect('localhost', 'root', 'password') # Noncompliant {{Review this potentially hard-coded credential.}}
-#                                            ^^^^^^^^^^
+        pymysql.connect('localhost', 'root', 'Azerty123') # Noncompliant {{Review this potentially hard-coded credential.}}
+#                                            ^^^^^^^^^^^
         pymysql.connections.Connection(host='localhost', user='root', password='password') # OK (avoid FPs)
-        pymysql.connections.Connection('localhost', 'root', 'password') # Noncompliant
+        pymysql.connections.Connection('localhost', 'root', 'Azerty123') # Noncompliant
         pymysql.connect(host='localhost', user='root', password=pwd) # OK
         pymysql.connect('localhost', 'root', pwd) # OK
         pymysql.connections.Connection(host='localhost', user='root', password=pwd) # OK
@@ -154,24 +156,24 @@ def db(self, pwd):
         psycopg2.connect(host='localhost', user='postgres', password=pwd,) # OK
 
         pgdb.connect(host='localhost', user='postgres', password='Azerty123') # Noncompliant
-        pgdb.connect('localhost', 'postgres', 'password') # Noncompliant
+        pgdb.connect('localhost', 'postgres', 'Azerty123') # Noncompliant
         pgdb.connect(host='localhost', user='postgres', password=pwd) # OK
         pgdb.connect('localhost', 'postgres', pwd) # OK
 
         pg.DB(host='localhost', user='postgres', passwd='Azerty123') # Noncompliant
-        pg.DB(None, 'localhost', 5432, None, 'postgres', 'password') # Noncompliant
+        pg.DB(None, 'localhost', 5432, None, 'postgres', 'Azerty123') # Noncompliant
         pg.DB(host='localhost', user='postgres', passwd=pwd) # OK
         pg.DB(None, 'localhost', 5432, None, 'postgres', pwd) # OK
 
         pg.connect(host='localhost', user='postgres', passwd='Azerty123') # Noncompliant
-        pg.connect(None, 'localhost', 5432, None, 'postgres', 'password') # Noncompliant
+        pg.connect(None, 'localhost', 5432, None, 'postgres', 'Azerty123') # Noncompliant
         pg.connect(host='localhost', user='postgres', passwd=pwd) # OK
         pg.connect(None, 'localhost', 5432, None, 'postgres', pwd) # OK
         pg.connect(host='localhost', user='postgres', passwd='') # Compliant
         pg.connect(None, 'localhost', 5432, None, 'postgres', '') # Compliant
 
         random.call(None, password = 42) # OK
-        random.call(None, password = "hello") # Noncompliant
+        random.call(None, password = "Azerty123") # Noncompliant
         random.call(None, password = "") # OK
         pg.connect(*unpack, 'localhost', 5432, None, 'postgres', pwd) # OK
 
@@ -184,7 +186,7 @@ def somePassword(self, password=42):  # OK
         pass
     def somePassword(self, password=""):  # OK
         pass
-    def somePassword(self, *, password="hello"): # Noncompliant
+    def somePassword(self, *, password="Azerty123"): # Noncompliant
         pass
 
 instance = A()
@@ -197,6 +199,8 @@ def somePassword(self, *, password="hello"): # Noncompliant
         'USER': 'sonarsource',
         'PASSWORD': 'azerty123',                    # Noncompliant
         'PASSWORD': os.getenv('DB_PASSWORD'),       # Compliant
+        'PASSWORD': os.getenv("DB_PASSWORD", "Azerty123"), # Noncompliant
+        'PASSWORD': os.environ.get("DB_PASSWORD", "Azerty123"),  # Noncompliant
         'HOST': 'localhost',
         'PORT': '5432'
     },
@@ -206,6 +210,8 @@ def somePassword(self, *, password="hello"): # Noncompliant
         'USER': 'sonarsource',
         'PASSWORD': 'azerty123',                    # Noncompliant
         'PASSWORD': os.getenv('DB_PASSWORD'),       # Compliant
+        'PASSWORD': os.getenv("DB_PASSWORD", "Azerty123"), # Noncompliant
+        'PASSWORD': os.environ.get("DB_PASSWORD", "Azerty123"),  # Noncompliant
         'HOST': 'localhost',
         'PORT': '5432'
     }
@@ -229,3 +235,11 @@ def test_flask():
     app.config["SECURITY_PASSWORD_HASH"] = "sha512_crypt"  # Compliant
     a, app.config["SECRET_KEY"] = "foo", "foo"  # Noncompliant
     app.config["SECURITY_PASSWORD_HASH"], app.config["SECRET_KEY"] = "foo", "foo"  # Noncompliant
+
+def test_secret_classifier():
+    # Values recognized by SecretClassifier as known non-secrets don't raise, even though the name matches.
+    password = "changeme"                                   # Compliant, well-known placeholder secret
+    password = "Xk28"                                        # Compliant, too short to be a real secret
+    password = "${SECRET_KEY}"                               # Compliant, variable interpolation
+    password = "op://vault/secret"                           # Compliant, external secret store reference
+    password = "{cipher}1e3faa2cdab2deae117dca102e52922a"    # Compliant, encrypted marker
diff --git a/python-checks/src/test/resources/checks/hardCodedCredentialsCustom.py b/python-checks/src/test/resources/checks/hardCodedCredentialsCustom.py
index 0f31b33dfa..74140fd880 100644
--- a/python-checks/src/test/resources/checks/hardCodedCredentialsCustom.py
+++ b/python-checks/src/test/resources/checks/hardCodedCredentialsCustom.py
@@ -1,4 +1,4 @@
-watermelon = "Qwerty123" # Noncompliant {{"watermelon" detected here, review this potentially hard-coded credential.}}
+watermelon = "Zx91Kdfg" # Noncompliant {{"watermelon" detected here, review this potentially hard-coded credential.}}
 pomelo = "Azerty123" # Noncompliant {{"pomelo" detected here, review this potentially hard-coded credential.}}
 
 password = "toto" # OK
diff --git a/python-checks/src/test/resources/checks/hardcodedCredentialsCall.py b/python-checks/src/test/resources/checks/hardcodedCredentialsCall.py
index 8892a16526..684a78e321 100644
--- a/python-checks/src/test/resources/checks/hardcodedCredentialsCall.py
+++ b/python-checks/src/test/resources/checks/hardcodedCredentialsCall.py
@@ -5,10 +5,10 @@
 def obj_creation_hardcoded_credentials():
     network = pylast.LibreFMNetwork("api_key", # Noncompliant {{Revoke and change this password, as it is compromised.}}
 #                                   ^^^^^^^^^ 0
-                                    "api_secret", # Noncompliant
+                                    "Azerty123", # Noncompliant
                                     "session_key",
                                     "username",
-                                    "password_hash") # Noncompliant
+                                    "Azerty123") # Noncompliant
 
 def obj_creation_empty_credentials():
     network = pylast.LibreFMNetwork("", "", "", "", "")
@@ -19,32 +19,32 @@ def obj_creation_empty_credentials():
 def obj_creation_hardcoded_credentials_named_arguments():
     network = pylast.LibreFMNetwork(api_key="api_key", # Noncompliant {{Revoke and change this password, as it is compromised.}}
 #                                   ^^^^^^^^^^^^^^^^^ 0
-                                    api_secret="api_secret", # Noncompliant
+                                    api_secret="Azerty123", # Noncompliant
                                     session_key="session_key",
                                     username="username",
-                                    password_hash="password_hash") # Noncompliant
+                                    password_hash="Azerty123") # Noncompliant
 
-    temp_user = test_connection.TempUser(password="password") # Noncompliant
+    temp_user = test_connection.TempUser(password="Azerty123") # Noncompliant
 
 
 def obj_creation_hardcoded_assigned_value(password):
     temp_user = test_connection.TempUser(password=password)
     temp_user = test_connection.TempUser(password=foo())
 
-    api_key = "abc"
-#             ^^^^^> 1 {{Revoke and change this password, as it is compromised.}}
+    api_key = "Azerty123"
+#             ^^^^^^^^^^^> 1 {{Revoke and change this password, as it is compromised.}}
     network = pylast.LibreFMNetwork(api_key=api_key) # Noncompliant
 #                                   ^^^^^^^^^^^^^^^ 1
 
-    value = "abcd"
-#           ^^^^^^> 1 {{Revoke and change this password, as it is compromised.}}
+    value = "Azerty123"
+#           ^^^^^^^^^^^> 1 {{Revoke and change this password, as it is compromised.}}
     api_secret = value
     network = pylast.LibreFMNetwork(api_secret=api_secret) # Noncompliant
 #                                   ^^^^^^^^^^^^^^^^^^^^^ 1
 
 
 def top_level_function_call():
-    psycopg2cffi.connect(password="abc") # Noncompliant
+    psycopg2cffi.connect(password="Azerty123") # Noncompliant
 
 
 # Methods manually defined in "manual_hardcoded_credentials_call_check_meta.json"
@@ -58,22 +58,22 @@ def top_level_function_call():
 import boto3
 
 def manually_defined_method_calls_with_named_params():
-    psycopg.connect(password="abc") # Noncompliant
-    psycopg2.connect(password="abc") # Noncompliant
-    mysql.connector.connect(password='abc') # Noncompliant
-    mysql.connector.connect(passwd='abc') # Noncompliant
-    mysql.connector.connect(password1='abc', password2='abc', password3='abc') # Noncompliant 3
-    MySQLConnection(password='abc') # Noncompliant
-    MySQLConnection(passwd='abc') # Noncompliant
-    MySQLConnection(password1='abc', password2='abc', password3='abc') # Noncompliant 3
-    pymysql.connect(password="abc") # Noncompliant
-    pymysql.connect(passwd="abc") # Noncompliant
-    r.Redis(password="abc") # Noncompliant
-    MongoClient(password="abc") # Noncompliant
-    boto3.resource(aws_secret_access_key="abc") # Noncompliant
+    psycopg.connect(password="Azerty123") # Noncompliant
+    psycopg2.connect(password="Azerty123") # Noncompliant
+    mysql.connector.connect(password='Azerty123') # Noncompliant
+    mysql.connector.connect(passwd='Azerty123') # Noncompliant
+    mysql.connector.connect(password1='Azerty123', password2='Azerty123', password3='Azerty123') # Noncompliant 3
+    MySQLConnection(password='Azerty123') # Noncompliant
+    MySQLConnection(passwd='Azerty123') # Noncompliant
+    MySQLConnection(password1='Azerty123', password2='Azerty123', password3='Azerty123') # Noncompliant 3
+    pymysql.connect(password="Azerty123") # Noncompliant
+    pymysql.connect(passwd="Azerty123") # Noncompliant
+    r.Redis(password="Azerty123") # Noncompliant
+    MongoClient(password="Azerty123") # Noncompliant
+    boto3.resource(aws_secret_access_key="Azerty123") # Noncompliant
 
 def manually_defined_method_calls_with_positional_params():
-    r.Redis("host", "port", "db", "password") # Noncompliant
+    r.Redis("host", "port", "db", "Azerty123") # Noncompliant
     # The following calls are compliant because the password can't be a positional parameter
     psycopg.connect("abc")
     psycopg2.connect("abc")
@@ -119,10 +119,10 @@ def db_connect(pwd, PASS):
 
     mysql.connector.connection.MySQLConnection(host='localhost', user='sonarsource', password='')
     pymysql.connect(host='localhost', user='sonarsource', password='')
-    pymysql.connections.Connection(host='localhost', user='sonarsource', password='abc') # Noncompliant
+    pymysql.connections.Connection(host='localhost', user='sonarsource', password='Azerty123') # Noncompliant
     pymysql.connections.Connection(host='localhost', user='sonarsource', password=f'{PASS}') # Compliant
     pymysql.connections.Connection(host='localhost', user='sonarsource', password=f'') # Compliant
-    pymysql.connections.Connection(host='localhost', user='sonarsource', password=f'pass') # Noncompliant
+    pymysql.connections.Connection(host='localhost', user='sonarsource', password=f'Azerty123') # Noncompliant
     psycopg2.connect(host='localhost', user='postgres', password='')
     pgdb.connect(host='localhost', user='postgres', password='')
 
@@ -132,8 +132,8 @@ def db_connect(pwd, PASS):
 
 
 def byte_decode_hardcoded_value():
-    apiKey = b"abc".decode("utf-8")
-#            ^^^^^^> 1 {{Revoke and change this password, as it is compromised.}}
+    apiKey = b"Azerty123".decode("utf-8")
+#            ^^^^^^^^^^^^> 1 {{Revoke and change this password, as it is compromised.}}
     network = pylast.LibreFMNetwork(api_key = apiKey) # Noncompliant {{Revoke and change this password, as it is compromised.}}
 #                                   ^^^^^^^^^^^^^^^^ 1
 
@@ -152,4 +152,4 @@ def oauth2_session():
 
     oauth.fetch_token(
         'https://api.example.com/o/oauth2/token',
-        client_secret='example_Password') # Noncompliant
+        client_secret='Azerty123') # Noncompliant
diff --git a/python-checks/src/test/resources/checks/hardcodedIP.py b/python-checks/src/test/resources/checks/hardcodedIP.py
index ea29346e0d..f27c91134d 100644
--- a/python-checks/src/test/resources/checks/hardcodedIP.py
+++ b/python-checks/src/test/resources/checks/hardcodedIP.py
@@ -22,6 +22,16 @@
 fileName = "v0.0.1.200__do_something.sql" # Compliant - suffixed and prefixed
 version = "1.0.0.0-1" # Compliant - suffixed
 
+__version__ = "26.8.0.1" # Compliant
+__version__ = ("26.8.0.1") # Compliant
+__version__: str = "26.8.0.1" # Compliant
+(__version__) = "26.8.0.1" # Compliant
+version = "26.8.0.1" # Noncompliant
+VERSION = "26.8.0.1" # Noncompliant
+__version__ = version = "26.8.0.1" # Noncompliant
+metadata.__version__ = "26.8.0.1" # Noncompliant
+versions["__version__"] = "26.8.0.1" # Noncompliant
+
 "1080:0:0:0:8:800:200C:417A" # Noncompliant {{Make sure using this hardcoded IP address "1080:0:0:0:8:800:200C:417A" is safe here.}}
 "[1080::8:800:200C:417A]" # Noncompliant
 "::800:200C:417A" # Noncompliant
diff --git a/python-checks/src/test/resources/checks/hardcodedIPDjango.py b/python-checks/src/test/resources/checks/hardcodedIPDjango.py
new file mode 100644
index 0000000000..edc7fc3f53
--- /dev/null
+++ b/python-checks/src/test/resources/checks/hardcodedIPDjango.py
@@ -0,0 +1,6 @@
+from django.test import TestCase
+
+
+class FailedLoginAttemptRepositoryTest(TestCase):
+    def test_delete_removes_matching_record(self):
+        self.repository.delete("8.8.8.8", "dave")
diff --git a/python-checks/src/test/resources/checks/hotspots/clearTextProtocols.py b/python-checks/src/test/resources/checks/hotspots/clearTextProtocols.py
index 6cb89b0541..295dd49813 100644
--- a/python-checks/src/test/resources/checks/hotspots/clearTextProtocols.py
+++ b/python-checks/src/test/resources/checks/hotspots/clearTextProtocols.py
@@ -4,9 +4,10 @@
 from ftplib import FTP
 import smtplib
 import ssl
+import urllib.request
 
 def clear_text_protocol():
-  url = "http://" # Noncompliant {{Using http protocol is insecure. Use https instead}}
+  url = "http://" # Noncompliant {{Using HTTP protocol is insecure. Use HTTPS instead.}}
   #     ^^^^^^^^^
   url = "http://exemple.com" # Noncompliant
   url = "http://0001::1" # Noncompliant
@@ -17,10 +18,10 @@ def clear_text_protocol():
   url = "http://subdomain.exemple.com" # Noncompliant
   #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-  url = "ftp://" # Noncompliant {{Using ftp protocol is insecure. Use sftp, scp or ftps instead}}
+  url = "ftp://" # Noncompliant {{Using FTP protocol is insecure. Use SFTP, SCP or FTPS instead.}}
   url = "ftp://anonymous@exemple.com" # Noncompliant
   url = "telnet://" # Noncompliant
-  url = "telnet://anonymous@exemple.com" # Noncompliant {{Using telnet protocol is insecure. Use ssh instead}}
+  url = "telnet://anonymous@exemple.com" # Noncompliant {{Using Telnet protocol is insecure. Use SSH instead.}}
 
   # Argument default value
   def download(url='http://exemple.com'): # Noncompliant
@@ -41,7 +42,7 @@ def download(url='http://exemple.com'): # Noncompliant
   # The url domain component is a loopback address.
   url = "http://localhost" # Compliant
   url = "http://127.0.0.1" # Compliant
-  url = "http://::1" # Compliant
+  url = "http://::1" # Noncompliant
   url = "ftp://user@localhost" # Compliant
 
   # url without authority
@@ -52,10 +53,10 @@ def download(url='ssh://exemple.com'): # Compliant
       print(url)
 
 
-  cnx = telnetlib.Telnet("towel.blinkenlights.nl") # Noncompliant {{Using telnet protocol is insecure. Use ssh instead}}
+  cnx = telnetlib.Telnet("towel.blinkenlights.nl") # Noncompliant {{Using Telnet protocol is insecure. Use SSH instead.}}
   #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   cnx = Telnet("towel.blinkenlights.nl") # Noncompliant
-  cnx = ftplib.FTP("194.244.111.175") # Noncompliant  {{Using ftp protocol is insecure. Use sftp, scp or ftps instead}}
+  cnx = ftplib.FTP("194.244.111.175") # Noncompliant  {{Using FTP protocol is insecure. Use SFTP, SCP or FTPS instead.}}
   cnx = FTP("194.244.111.175") # Noncompliant
   cnx = ftplib.FTP_TLS("secure.example.com") # Compliant
   cnx = FTP_TLS("secure.example.com") # Compliant
@@ -77,17 +78,49 @@ def download(url='ssh://exemple.com'): # Compliant
   url = "http://127.63.31.15" # Compliant
   url = "http://127.255.255.254" # Compliant
 
-  url = "http://0:0:0:0:0:0:0:1" # Compliant
-  url = "http://0000:0000:0000:0000:0000:0000:0000:0001" # Compliant
-  url = "http://::1" # Compliant
-  url = "http://0::1" # Compliant
-  url = "http://0:0:0::1" # Compliant
-  url = "http://0000::0001" # Compliant
-  url = "http://0000:0:0000::0001" # Compliant
-  url = "http://0000:0:0000::1" # Compliant
-  url = "http://0::0:1" # Compliant
+  # Unbracketed IPv6 is not a valid HTTP URL (RFC 3986 requires brackets); the new filter no longer treats these as safe
+  url = "http://0:0:0:0:0:0:0:1" # Noncompliant
+  url = "http://0000:0000:0000:0000:0000:0000:0000:0001" # Noncompliant
+  url = "http://::1" # Noncompliant
+  url = "http://0::1" # Noncompliant
+  url = "http://0:0:0::1" # Noncompliant
+  url = "http://0000::0001" # Noncompliant
+  url = "http://0000:0:0000::0001" # Noncompliant
+  url = "http://0000:0:0000::1" # Noncompliant
+  url = "http://0::0:1" # Noncompliant
   url = "ftp://user@localhost" # Compliant
 
+  # Bracketed IPv6 loopback is a valid URL and is safe
+  url = "http://[::1]" # Compliant
+  url = "http://[0:0:0:0:0:0:0:1]" # Compliant
+  url = "http://[::1]:8080/api" # Compliant
+
+  # Cloud instance metadata endpoints are internal and not publicly reachable
+  url = "http://169.254.169.254/latest/meta-data/" # Compliant
+  url = "http://169.254.169.254/latest/api/token" # Compliant
+  url = "http://[fd00:ec2::254]/latest/meta-data/" # Compliant
+  url = "http://168.63.129.16/" # Compliant
+  url = "http://100.100.100.200/latest/meta-data/" # Compliant
+  url = "http://metadata.google.internal/computeMetadata/v1" # Compliant
+
+  # Docker and Kubernetes internal hostnames are not publicly reachable
+  url = "http://host.docker.internal:8085/metrics" # Compliant
+  url = "http://vault.vault.svc.cluster.local:8200" # Compliant
+  url = "http://auth-service.prod.svc.cluster.local:3001/auth" # Compliant
+
+  # Well-known namespace URI authorities: http:// prefix is part of the identifier, not a network endpoint
+  url = "http://www.w3.org/2001/XMLSchema" # Compliant
+  url = "http://schemas.xmlsoap.org/soap/envelope/" # Compliant
+  url = "http://www.springframework.org/schema/beans" # Compliant
+  url = "http://maven.apache.org/POM/4.0.0" # Compliant
+  url = "http://schema.org/Person" # Compliant
+
+  # IANA-reserved documentation domains are placeholder URLs, not real endpoints
+  url = "http://example.com/path" # Compliant
+  url = "http://example.net" # Compliant
+  url = "http://api.example.com/v1/users" # Compliant
+  url = "ftp://example.com/file" # Compliant
+
   self.server_url = 'http://127.0.0.1:%s' % self.server.port # compliant, loopback
   def get_url(self, path):
           return "http://127.0.0.1:%d%s" % (self.port, path) # compliant, loopback
@@ -122,6 +155,54 @@ def get_url(self, path):
   smtp4 = smtplib.SMTP("smtp.gmail.com", port=587) # Noncompliant
   unknown.unknwon(smtp4)
 
+
+def clear_text_protocol_used_as_prefix(url: str):
+  url.startswith("http://insecure.com") # Compliant
+  url.startswith(("http://insecure.com", "ftp://insecure.com", "https://secure.com")) # Compliant
+
+
+def clear_text_protocol_used_as_prefix_untyped(url):
+  url.startswith("http://insecure.com") # Compliant
+  url.startswith(("http://insecure.com", "ftp://insecure.com", "https://secure.com")) # Compliant
+
+
+def clear_text_protocol_used_as_prefix_unbound(url: str):
+  str.startswith(url, "http://insecure.com") # Compliant
+  str.startswith(url, ("http://insecure.com", "ftp://insecure.com", "https://secure.com")) # Compliant
+
+
+def clear_text_protocol_used_as_prefix_grouped(url: str):
+  url.startswith(("http://insecure.com")) # Compliant
+  url.startswith((("http://insecure.com"))) # Compliant
+
+
+def clear_text_protocol_used_outside_startswith_prefix(url: str):
+  check_protocol("http://insecure.com") # Noncompliant
+  url.endswith("http://insecure.com") # Noncompliant
+  url.startswith(prefix="http://insecure.com") # Noncompliant
+  str.startswith("http://insecure.com") # Noncompliant
+  url.startswith("https://secure.com", "http://insecure.com") # Noncompliant
+
+
+class ClearTextProtocolBase("http://insecure.com"): # Noncompliant
+  pass
+
+
+def clear_text_protocol_prefix_via_variable(url: str):
+  prefix = "http://insecure.com" # Noncompliant
+  url.startswith(prefix) # Compliant
+
+
+def clear_text_protocol_used_by_other_code():
+  urllib.request.urlopen("http://insecure.com") # Noncompliant
+
+  class ProtocolMatcher:
+    def startswith(self, prefix):
+      pass
+
+  ProtocolMatcher().startswith("http://insecure.com") # Noncompliant
+
+
 def method(self):
   self.something[smth] = None
 
diff --git a/python-checks/src/test/resources/checks/hotspots/commandLineArgs.py b/python-checks/src/test/resources/checks/hotspots/commandLineArgs.py
deleted file mode 100644
index 3a9d811551..0000000000
--- a/python-checks/src/test/resources/checks/hotspots/commandLineArgs.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import argparse
-from argparse import ArgumentParser
-
-import sys
-from sys import argv
-import mySys
-
-from optparse import OptionParser
-import optparse
-
-def argparse_test():
-    argparse.ArgumentParser() # Noncompliant {{Make sure that command line arguments are used safely here.}}
-#   ^^^^^^^^^^^^^^^^^^^^^^^
-    ArgumentParser() # Noncompliant
-    argparse.otherFunction() # OK
-
-def builtins():
-    sys.argv # Noncompliant
-#       ^^^^
-    argv # Noncompliant
-    mySys.argv # OK
-    sys.argv.remove('--force') # Noncompliant
-
-def optparse_test():
-    OptionParser() # Noncompliant
-    optparse.OptionParser() # Noncompliant
-
-
-@metrics.countMethod('AbstractBuildSlave.attached()')
-def attached(self, bot):
-  pass
diff --git a/python-checks/src/test/resources/checks/hotspots/data_encryption.py b/python-checks/src/test/resources/checks/hotspots/data_encryption.py
deleted file mode 100644
index ed84870909..0000000000
--- a/python-checks/src/test/resources/checks/hotspots/data_encryption.py
+++ /dev/null
@@ -1,81 +0,0 @@
-############################################
-###       pyca/cryptography library      ###
-############################################
-
-def pyca_cryptography():
-    from cryptography.fernet import Fernet
-    from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305, AESGCM, AESCCM
-    from cryptography.hazmat.primitives.asymmetric import rsa, ec, dsa, dh
-    from cryptography.hazmat.primitives.ciphers import Cipher
-
-    Fernet(key)                # Noncompliant
-    ChaCha20Poly1305(key)      # Noncompliant
-    AESGCM(key)                # Noncompliant
-    AESCCM(key)                # Noncompliant
-    Other_encryption_method()  # OK
-
-    parameters_dh = dh.generate_parameters(2, key_size, backend) # Noncompliant {{Make sure that encrypting data is safe here.}}
-#                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-    Cipher(algorithm, mode, backend)  # Noncompliant
-
-############################################
-###       pyca/pynacl library            ###
-############################################
-
-def pyca_cryptography():
-    from nacl.public import Box
-    from nacl.secret import SecretBox
-
-    Box(secret_key, public_key)  # Noncompliant
-    SecretBox(key)  # Noncompliant
-
-############################################
-###       PyCrypto library               ###
-############################################
-
-def pyCrypto():
-    import Crypto
-    from Crypto.Cipher import AES, DES, DES3, ARC2, ARC4, Blowfish, CAST, PKCS1_v1_5, PKCS1_OAEP, XOR
-    from Crypto.PublicKey import ElGamal
-
-    Crypto.Cipher.AES.new()       # Noncompliant
-    Crypto.Other.AES.new()        # OK
-    AES.new(key=key)              # Noncompliant
-    DES.new(key=key)              # Noncompliant
-    DES3.new(key=key)             # Noncompliant
-    ARC2.new(key=key)             # Noncompliant
-    ARC4.new(key=key)             # Noncompliant
-    Blowfish.new(key=key)         # Noncompliant
-    CAST.new(key=key)             # Noncompliant
-    PKCS1_v1_5.new(key=key)       # Noncompliant
-    PKCS1_OAEP.new(key=key)       # Noncompliant
-    XOR.new(key=key)              # Noncompliant
-
-    ElGamal.generate(key_size)    # Noncompliant
-
-
-############################################
-###       Cryptodome library             ###
-############################################
-
-def pyCrypto():
-    import Cryptodome
-    from Cryptodome.Cipher import AES, ChaCha20, DES, DES3, ARC2, ARC4, Blowfish, CAST, PKCS1_v1_5, PKCS1_OAEP, ChaCha20_Poly1305, Salsa20
-    from Cryptodome.PublicKey import ElGamal
-
-    Cryptodome.Cipher.AES.new()    # Noncompliant
-    Cryptodome.Other.AES.new()     # OK
-    AES.new(key=key)               # Noncompliant
-    ChaCha20.new(key=key)          # Noncompliant
-    DES.new(key=key)               # Noncompliant
-    DES3.new(key=key)              # Noncompliant
-    ARC2.new(key=key)              # Noncompliant
-    ARC4.new(key=key)              # Noncompliant
-    Blowfish.new(key=key)          # Noncompliant
-    CAST.new(key=key)              # Noncompliant
-    PKCS1_v1_5.new(key=key)        # Noncompliant
-    PKCS1_OAEP.new(key=key)        # Noncompliant
-    ChaCha20_Poly1305.new(key=key) # Noncompliant
-    Salsa20.new(key=key)           # Noncompliant
-
-    ElGamal.generate(key_size)     # Noncompliant
diff --git a/python-checks/src/test/resources/checks/hotspots/dynamicCodeExecution.py b/python-checks/src/test/resources/checks/hotspots/dynamicCodeExecution.py
deleted file mode 100644
index 682c6bcd62..0000000000
--- a/python-checks/src/test/resources/checks/hotspots/dynamicCodeExecution.py
+++ /dev/null
@@ -1,8 +0,0 @@
-def evaluate(command, file, mode):
-    eval(command) # Noncompliant
-#   ^^^^^^^^^^^^^
-    exec(code) # Noncompliant
-#   ^^^^^^^^^^
-    eval.f() # OK
-    myModule.eval() # OK
-    myEval(code) # OK
diff --git a/python-checks/src/test/resources/checks/hotspots/emailSending.py b/python-checks/src/test/resources/checks/hotspots/emailSending.py
deleted file mode 100644
index 4b6c9315be..0000000000
--- a/python-checks/src/test/resources/checks/hotspots/emailSending.py
+++ /dev/null
@@ -1,34 +0,0 @@
-def django_tests(subject, msg, from_email, to_email):
-  from django.core.mail import send_mail, send_mass_mail
-
-  send_mail(subject, msg, from_email, [to_email]) # Noncompliant {{Make sure that this email is sent in a safe manner.}}
-# ^^^^^^^^^
-  send_mass_mail((subject, msg, from_email, [to_email])) # Noncompliant
-
-def smtplib_tests(from_email, to_email, msg):
-    import smtplib
-    server1 = smtplib.SMTP('localhost', 1025)
-    server1.sendmail(from_email, to_email, msg) # Noncompliant
-    server1.send_message(msg, from_email, to_email) # Noncompliant
-
-    server2 = smtplib.SMTP_SSL('localhost', 1025)
-    server2.sendmail(from_email, to_email, msg) # Noncompliant
-    server2.send_message(msg, from_email, to_email) # Noncompliant
-
-    class A:
-        def sendmail(self): pass
-        def send_message(self): pass
-
-    a = A()
-    a.sendmail(from_email, to_email, msg) # OK
-    a.send_message(msg, from_email, to_email) # OK
-
-def flask_mail_tests(app, msg, subject, to_email, body, from_email):
-    from flask_mail import Mail, Connection
-    mail = Mail(app)
-    mail.send(msg) # Noncompliant
-    mail.send_message(subject, [to_email], body, sender=from_email) # Noncompliant
-
-    connection = Connection(mail)
-    connection.send(msg) # Noncompliant
-    connection.send_message(subject, [to_email], body, sender=from_email) # Noncompliant
diff --git a/python-checks/src/test/resources/checks/hotspots/filePermissions.py b/python-checks/src/test/resources/checks/hotspots/filePermissions.py
index be0aaea3a6..0c2e8fb735 100644
--- a/python-checks/src/test/resources/checks/hotspots/filePermissions.py
+++ b/python-checks/src/test/resources/checks/hotspots/filePermissions.py
@@ -62,6 +62,8 @@
 os.chmod("/tmp/fs", 256)  # Compliant -r--------
 os.chmod("/tmp/fs", 0)    # Compliant ----------
 
+os.chmod("/tmp/fs", 9223372036854775808)  # Compliant (mode literal does not parse to long)
+
 os.chmod("/tmp/fs", 4)     # Noncompliant
 os.chmod("/tmp/fs", 260)   # Noncompliant
 
diff --git a/python-checks/src/test/resources/checks/hotspots/graphQLIntrospection.py b/python-checks/src/test/resources/checks/hotspots/graphQLIntrospection.py
index 8711fa55e7..1d81c1872b 100644
--- a/python-checks/src/test/resources/checks/hotspots/graphQLIntrospection.py
+++ b/python-checks/src/test/resources/checks/hotspots/graphQLIntrospection.py
@@ -173,6 +173,14 @@ def flask_graphql_validation_rules_non_compliant(schema, some_rule):
         validation_rules=[some_rule]
     )
 
+    GraphQLView.as_view(  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^
+        name="introspection",
+        schema=schema,
+        graphiql=True,
+        validation_rules={some_rule}
+    )
+
     class UnsafeCustomMiddleware:
             ...
     my_custom_middleware = UnsafeCustomMiddleware()
@@ -185,7 +193,7 @@ class UnsafeCustomMiddleware:
             middleware=[my_custom_middleware]
         )
 
-def flask_graphql_validation_rules_compliant(schema, some_rule, some_middleware, introspection_rule):
+def flask_graphql_validation_rules_compliant(schema, some_rule, some_middleware, introspection_rule, introspection_middleware):
     from flask_graphql import GraphQLView
     import graphene
     from graphene.validation import DisableIntrospection
@@ -230,6 +238,20 @@ def flask_graphql_validation_rules_compliant(schema, some_rule, some_middleware,
         validation_rules=[introspection_rule]
     )
 
+    GraphQLView.as_view(
+        name="introspection",
+        schema=schema,
+        graphiql=True,
+        validation_rules={DisableIntrospection, some_rule}
+    )
+
+    GraphQLView.as_view(
+        name="introspection",
+        schema=schema,
+        graphiql=True,
+        middleware={introspection_middleware}
+    )
+
 def graphql_server_middleware_non_compliant(schema, some_middleware, CustomBackend, format_custom_error, some_module):
     from graphql_server.flask import GraphQLView
 
diff --git a/python-checks/src/test/resources/checks/hotspots/hashing/hashingData.py b/python-checks/src/test/resources/checks/hotspots/hashing/hashingData.py
index df9ca5815d..cc6310fd2f 100644
--- a/python-checks/src/test/resources/checks/hotspots/hashing/hashingData.py
+++ b/python-checks/src/test/resources/checks/hotspots/hashing/hashingData.py
@@ -135,6 +135,62 @@ def hash_data(algorithm):
 
     md5  # Noncompliant
 
+# S4790 suppressed when the hashlib call (or its .hexdigest()/.digest() qualifier)
+# is immediately consumed by a bounded slice — truncated output cannot serve
+# as a password hash, MAC, or integrity digest.
+def hash_for_identifier(payload, email, seed, n):
+    uid    = hashlib.sha1(b"data").hexdigest()[:8]          # OK — short identifier
+    short  = hashlib.md5(payload).digest()[:4]              # OK — bounded keyspace
+    prefix = hashlib.sha1(email.encode()).hexdigest()[0:5]  # OK — k-anonymity prefix
+    otp    = hashlib.sha1(seed).hexdigest()[-6:]            # OK — HOTP-style truncation
+    direct = hashlib.md5(payload)[:8]                       # OK — direct slice without digest call
+    s224   = hashlib.sha224(b"data").hexdigest()[:8]        # OK — sha224 with bounded slice
+
+    # Still flagged: slice bound too large (could be full-digest use)
+    hashlib.sha1(b"data").hexdigest()[:]        # Noncompliant
+    hashlib.sha1(b"data").hexdigest()[:17]      # Noncompliant
+    hashlib.sha1(b"data").hexdigest()[-17:]     # Noncompliant
+
+    # Still flagged: variable or dynamic bound — not a literal
+    hashlib.sha1(b"data").hexdigest()[:n]       # Noncompliant
+
+    # Still flagged: stride present — bounded size not guaranteed
+    hashlib.sha1(b"data").hexdigest()[-6::2]    # Noncompliant
+
+    # Still flagged: positive lower bound with no upper — unbounded tail
+    hashlib.sha1(b"data").hexdigest()[6:]       # Noncompliant
+
+    # Still flagged: zero upper bound
+    hashlib.sha1(b"data").hexdigest()[:0]       # Noncompliant
+
+    # Still flagged: chained method is neither hexdigest nor digest
+    hashlib.sha1(b"data").copy()[:8]            # Noncompliant
+
+    # Still flagged: hexdigest accessed as attribute, not called
+    hashlib.sha1(b"data").hexdigest             # Noncompliant
+
+    # Still flagged: negative upper bound keeps almost the whole digest
+    hashlib.sha1(b"data").hexdigest()[:-4]      # Noncompliant
+
+    # Still flagged: multi-dimensional slice
+    hashlib.sha1(b"data").hexdigest()[1:4, 2:8] # Noncompliant
+
+    # Still flagged: float literal upper bound
+    hashlib.sha1(b"data").hexdigest()[:1.5]     # Noncompliant
+
+    # Still flagged: float literal lower bound magnitude
+    hashlib.sha1(b"data").hexdigest()[-1.5:]    # Noncompliant
+
+    # Still flagged: unary plus lower bound
+    hashlib.sha1(b"data").hexdigest()[+5:]      # Noncompliant
+
+    # Still flagged: variable under unary minus
+    hashlib.sha1(b"data").hexdigest()[-n:]      # Noncompliant
+
+    # Still flagged: intermediate variable breaks the chain
+    h = hashlib.sha1(b"data")                  # Noncompliant
+    h.hexdigest()[:8]
+
 def test_if_usedforsecurity_works_only_for_hashlib():
     import Cryptodome
     Cryptodome.Hash.MD2.new(usedforsecurity=False) # Noncompliant
diff --git a/python-checks/src/test/resources/checks/hotspots/loggersConfiguration.py b/python-checks/src/test/resources/checks/hotspots/loggersConfiguration.py
deleted file mode 100644
index b0ed102b9f..0000000000
--- a/python-checks/src/test/resources/checks/hotspots/loggersConfiguration.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import logging
-from logging import Logger, Handler, Filter
-from logging.config import fileConfig, dictConfig
-
-logging.basicConfig()  # Noncompliant {{Make sure that this logger's configuration is safe.}}
-
-logging.disable()      # Noncompliant
-
-
-def update_logging(logger_class):
-    foo().setLoggerClass(logger_class)    # OK
-    logging.otherFn(logger_class)         # OK
-    logging.setLoggerClass(logger_class)  # Noncompliant
-#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-
-def set_last_resort(last_resort):
-    logging.lastResort = last_resort          # Noncompliant
-#   ^^^^^^^^^^^^^^^^^^
-    foo().lastResort = last_resort            # OK
-    lastResort()  = last_resort               # OK
-    logging.other = last_resort               # OK
-
-def set_last_resert_multiple_assignment(last_resort):
-    import logging
-    logging.lastResort, foo = last_resort, 2  # Noncompliant
-
-class CustomLogger(Logger):    # Noncompliant
-#                  ^^^^^^
-    pass
-
-class CustomLogger(foo()):    # OK
-    pass
-
-class CustomLogger():         # OK
-    pass
-
-class CustomLogger(OtherLogger):        # OK
-    pass
-
-class CustomLogger(logging.OtherClass): # OK
-    pass
-
-class CustomHandler(Handler):  # Noncompliant
-    pass
-
-
-class CustomFilter(Filter):    # Noncompliant
-    pass
-
-
-def update_config(path, config):
-    fileConfig(path)    # Noncompliant
-    dictConfig(config)  # Noncompliant
diff --git a/python-checks/src/test/resources/checks/hotspots/osExec.py b/python-checks/src/test/resources/checks/hotspots/osExec.py
deleted file mode 100644
index 3c518c0c36..0000000000
--- a/python-checks/src/test/resources/checks/hotspots/osExec.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import os
-import subprocess
-from subprocess import run, call, check_call, check_output, Popen
-
-# See https://docs.python.org/3/library/subprocess.html
-params = ["ls", "-l"]
-subprocess.run(params)  # Noncompliant
-run(params)  # Noncompliant
-subprocess.Popen(params)  # Noncompliant
-Popen(params)  # Noncompliant
-
-# Older API
-subprocess.call(params)  # Noncompliant
-call(params)  # Noncompliant
-subprocess.check_call(params)  # Noncompliant
-check_call(params)  # Noncompliant
-subprocess.check_output(params)  # Noncompliant
-check_output(params)  # Noncompliant
-
-# See https://docs.python.org/3/library/os.html
-cmd = "ls -l"
-os.system(cmd)  # Noncompliant
-mode = os.P_WAIT
-file = "ls"
-path = "/bin/ls"
-env = os.environ
-os.spawnl(mode, path, *params)  # Noncompliant
-os.spawnle(mode, path, *params, env)  # Noncompliant
-os.spawnlp(mode, file, *params)  # Noncompliant
-os.spawnlpe(mode, file, *params, env)  # Noncompliant
-os.spawnv(mode, path, params)  # Noncompliant
-os.spawnve(mode, path, params, env)  # Noncompliant
-os.spawnvp(mode, file, params)  # Noncompliant
-os.spawnvpe(mode, file, params, env)  # Noncompliant
-mode = 'r'
-(child_stdout) = os.popen(cmd, mode, 1)  # Noncompliant
-
-# print(child_stdout.read())
-(_, output) = subprocess.getstatusoutput(cmd)  # Noncompliant
-out = subprocess.getoutput(cmd)  # Noncompliant
-os.startfile(path)  # Noncompliant
-os.execl(path, *params)  # Noncompliant
-os.execle(path, *params, env)  # Noncompliant
-os.execlp(file, *params)  # Noncompliant
-os.execlpe(file, *params, env)  # Noncompliant
-os.execv(path, params)  # Noncompliant
-os.execve(path, params, env)  # Noncompliant
-os.execvp(file, params)  # Noncompliant
-os.execvpe(file, params, env)  # Noncompliant
diff --git a/python-checks/src/test/resources/checks/hotspots/regex.py b/python-checks/src/test/resources/checks/hotspots/regex.py
deleted file mode 100644
index fc5d57d4fc..0000000000
--- a/python-checks/src/test/resources/checks/hotspots/regex.py
+++ /dev/null
@@ -1,69 +0,0 @@
-from django.core.validators import RegexValidator
-from django.urls import re_path
-
-def build_validator(regex):
-    RegexValidator(regex)  # OK
-
-RegexValidator()
-RegexValidator('')
-RegexValidator('a+')
-RegexValidator('a*')
-RegexValidator('a{1}')
-RegexValidator('(a*)*')  # Noncompliant {{Make sure that using a regular expression is safe here.}}
-#              ^^^^^^^
-RegexValidator('(a{1})*') # Noncompliant
-RegexValidator('((a+)*') # Noncompliant
-RegexValidator('(a{1})+') # Noncompliant
-RegexValidator('(a+)+') # Noncompliant
-RegexValidator('(a{1}){2}') # Noncompliant
-RegexValidator(x:='(a+)+') # Noncompliant
-RegexValidator((x:='(a+)+')) # Noncompliant
-RegexValidator(x:='a+')
-RegexValidator(42)
-
-
-def define_http_endpoint(path, view):
-    re_path(path, view)  # OK
-    regexp = '(a*)*'
-#            ^^^^^^^>
-    RegexValidator(regexp) # Noncompliant
-#                  ^^^^^^
-    RegexValidator(*path)
-    something = 42
-    RegexValidator(something)
-
-import re
-from re import compile
-
-def dynamic_pattern():
-    pattern = '(a*)*'
-    re.compile(pattern)  # Noncompliant
-    compile(pattern) # FN - Same name as built-in symbol compile
-    regexpressions.map(compile) # OK
-
-import regex
-from regex import subf
-
-
-def dynamic_pattern(pattern):
-    regex.subf(pattern, replacement, input)  # OK
-    subf(pattern, replacement, input)  # OK
-
-
-beforethisafter = r'\s*(?P%s(?=\s*(\b(%s)\b)))' + \
-    r'\s*(?P(\b(%s)\b))' + \
-    r'\s*(?P%s)\s*\Z'
-##
-fortrantypes = r'character|logical|integer|real|complex|double\s*(precision\s*(complex|)|complex)|type(?=\s*\([\w\s,=(*)]*\))|byte'
-typespattern = re.compile(
-    beforethisafter % ('', fortrantypes, fortrantypes, '.*'), re.I) # Noncompliant
-
-def test_valid_numpy_version():
-    version_pattern = r"^[0-9]+\.[0-9]+\.[0-9]+(|a[0-9]|b[0-9]|rc[0-9])"
-    if np.version.release:
-        res = re.match(version_pattern, np.__version__) # Noncompliant
-    else:
-        res = re.match(version_pattern + dev_suffix, np.__version__) # Noncompliant
-
-def formatted_regex():
-  pattern = re.compile(r'{}-\d+-{}$'.format(foo, bar))
diff --git a/python-checks/src/test/resources/checks/hotspots/sqlQuery.py b/python-checks/src/test/resources/checks/hotspots/sqlQuery.py
index 488e93afe8..4ae764d08f 100644
--- a/python-checks/src/test/resources/checks/hotspots/sqlQuery.py
+++ b/python-checks/src/test/resources/checks/hotspots/sqlQuery.py
@@ -30,7 +30,7 @@ def query_my_user(request, params):
         MyUser.objects.raw(formatted_request3)  # Noncompliant
         MyUser.objects.raw(y := formatted_request3)  # Noncompliant
         MyUser.objects.raw((y := formatted_request3))  # Noncompliant
-        MyUser.objects.raw(formatted_request4)  # FN, multiple assignments
+        MyUser.objects.raw(formatted_request4)  # Noncompliant
         MyUser.objects.raw(formatted_request5)  # OK
         MyUser.objects.raw(*formatted_request5)  # OK
 
@@ -58,5 +58,21 @@ def query_my_user(request, params):
         MyUser.objects.extra({ 'mycol': "select col from sometable here mycol = %s and othercol = " + value}) # Noncompliant
         MyUser.objects.extra({ 'mycol': "select col from sometable here mycol = %s and othercol = " + ""}) # Noncompliant
 
+    def test_reaching_definitions(self, request, value):
+        query = "SELECT 1"
+        if request:
+            query = 'SELECT * FROM mytable WHERE name = "%s"' % value
+        MyUser.objects.raw(query)  # Noncompliant
+
+        safe_query = "SELECT 1"
+        if request:
+            safe_query = "SELECT 2"
+        MyUser.objects.raw(safe_query)  # OK
+
+        all_formatted = 'SELECT * FROM mytable WHERE name = "%s"' % value
+        if request:
+            all_formatted = f'SELECT * FROM mytable WHERE name = "{value}"'
+        MyUser.objects.raw(all_formatted)  # Noncompliant
+
      def fun():
         pass
diff --git a/python-checks/src/test/resources/checks/hotspots/standardInput.py b/python-checks/src/test/resources/checks/hotspots/standardInput.py
deleted file mode 100644
index 3e9eed0467..0000000000
--- a/python-checks/src/test/resources/checks/hotspots/standardInput.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import sys
-from sys import stdin, __stdin__
-import fileinput
-
-def python_3_builtin():
-    sys.stdin  # Noncompliant {{Make sure that reading the standard input is safe here.}}
-#       ^^^^^
-
-    sys.__stdin__  # Noncompliant
-
-    stdin #Noncompliant
-    __stdin__ #Noncompliant
-
-
-    sys.stdin.read()  # Noncompliant
-    sys.stdin.readline()  # Noncompliant
-    sys.stdin.readlines()  # Noncompliant
-
-    sys.__stdin__.read() # Noncompliant
-    sys.stdin.seekable()  # Ok
-
-    foo('stdin', sys.stdin) # Noncompliant
-    data = sys.stdin.read(1) # Noncompliant
-
-    input('What is your password?') # Noncompliant
-
-def python_2_builtin():
-    raw_input('What is your password?') # Noncompliant
-
-def from_fileinput():
-    fileinput.input() # Noncompliant
-    fileinput.FileInput() # Noncompliant
-
-    fileinput.input(['setup.py']) # OK
-    fileinput.FileInput(['setup.py']) # OK
-
-
-
-
diff --git a/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/django/urls.py b/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/django/urls.py
index 87202d3b12..6b219f7cfa 100644
--- a/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/django/urls.py
+++ b/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/django/urls.py
@@ -4,17 +4,38 @@
 from . import views_decorator_fqn_null
 
 urlpatterns = [
-  path('sensitive1', views.sensitive1, name='sensitive1'),
-  path('sensitive2', views.sensitive2, name='sensitive2'),
+  path('compliant_explicit_methods', views.compliant_explicit_methods, name='compliant_explicit_methods'),
   path('compliant_require_http_methods', views.compliant_require_http_methods, name='compliant_require_http_methods'),
   path('compliant_require_http_methods2', views.compliant_require_http_methods2, name='compliant_require_http_methods2'),
   path('compliant_require_http_methods3', views.compliant_require_http_methods3, name='compliant_require_http_methods3'),
   path('compliant_require_http_methods4', views.compliant_require_http_methods4, name='compliant_require_http_methods4'),
+  path('compliant_non_django_import', views.compliant_non_django_import, name='compliant_non_django_import'),
   path('compliant_require_http_methods5', views.compliant_require_http_methods5, name='compliant_require_http_methods5'),
   path('compliant_require_http_methods6', views.compliant_require_http_methods6, name='compliant_require_http_methods6'),
   path('compliant', views_decorator_fqn_null.compliant, name='compliant'),
   path('compliant_require_post', views.compliant_require_post, name='compliant_require_post'),
   path('compliant_require_get', views.compliant_require_get, name='compliant_require_get'),
   path('compliant_require_safe', views.compliant_require_safe, name='compliant_require_safe'),
-  path('sensitive_other_dec', views.sensitive_other_dec, name='sensitive_other_dec'),
+  path('compliant_method_eq_check', views.compliant_method_eq_check, name='compliant_method_eq_check'),
+  path('compliant_method_eq_check_swapped', views.compliant_method_eq_check_swapped, name='compliant_method_eq_check_swapped'),
+  path('compliant_method_in_check', views.compliant_method_in_check, name='compliant_method_in_check'),
+  path('compliant_method_check_and_condition', views.compliant_method_check_and_condition, name='compliant_method_check_and_condition'),
+  path('compliant_method_check_parenthesized', views.compliant_method_check_parenthesized, name='compliant_method_check_parenthesized'),
+  path('compliant_method_check_elif', views.compliant_method_check_elif, name='compliant_method_check_elif'),
+  path('compliant_method_check_in_nested_scope', views.compliant_method_check_in_nested_scope, name='compliant_method_check_in_nested_scope'),
+  path('noncompliant_nested_function', views.noncompliant_nested_function, name='noncompliant_nested_function'),
+  path('noncompliant_lambda', views.noncompliant_lambda, name='noncompliant_lambda'),
+  path('noncompliant1', views.noncompliant1, name='noncompliant1'),
+  path('noncompliant_other_dec', views.noncompliant_other_dec, name='noncompliant_other_dec'),
+  path('noncompliant_login_required', views.noncompliant_login_required, name='noncompliant_login_required'),
+  path('noncompliant_permission_required', views.noncompliant_permission_required, name='noncompliant_permission_required'),
+  path('noncompliant_method_on_other_var', views.noncompliant_method_on_other_var, name='noncompliant_method_on_other_var'),
+  path('noncompliant_method_on_different_var', views.noncompliant_method_on_different_var, name='noncompliant_method_on_different_var'),
+  path('noncompliant_other_if_eq_check', views.noncompliant_other_if_eq_check, name='noncompliant_other_if_eq_check'),
+  path('noncompliant_method_truthy_check', views.noncompliant_method_truthy_check, name='noncompliant_method_truthy_check'),
+  path('noncompliant_method_and_check', views.noncompliant_method_and_check, name='noncompliant_method_and_check'),
+  path('noncompliant_method_only_printed', views.noncompliant_method_only_printed, name='noncompliant_method_only_printed'),
+  path('noncompliant_method_comparison_not_in_if', views.noncompliant_method_comparison_not_in_if, name='noncompliant_method_comparison_not_in_if'),
+  path('noncompliant_request_used_as_argument', views.noncompliant_request_used_as_argument, name='noncompliant_request_used_as_argument'),
+  path('noncompliant_tuple_param_only', views.noncompliant_tuple_param_only, name='noncompliant_tuple_param_only'),
 ]
diff --git a/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/django/views.py b/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/django/views.py
index e029c79727..e33f37dcd6 100644
--- a/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/django/views.py
+++ b/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/django/views.py
@@ -1,10 +1,9 @@
 from django.views.decorators.http import require_http_methods, require_POST, require_GET, require_safe, other_decorator
+from django.contrib.auth.decorators import login_required, permission_required
+from some_framework import view_decorator
 
-def sensitive1(request):  # Noncompliant
-  ...
-
-@require_http_methods(["GET", "POST"])  # Noncompliant
-def sensitive2(request):
+@require_http_methods(["GET", "POST"])  # Compliant - methods explicitly specified
+def compliant_explicit_methods(request):
   ...
 
 @require_http_methods(["POST"])  # Compliant
@@ -14,6 +13,7 @@ def compliant_require_http_methods(request):
 @require_http_methods(["GET"])  # Compliant
 def compliant_require_http_methods2(request):
   ...
+
 @require_http_methods()  # Compliant
 def compliant_require_http_methods3(request):
   ...
@@ -23,13 +23,17 @@ def compliant_require_http_methods3(request):
 def compliant_require_http_methods4(request):
     ...
 
+@view_decorator  # Compliant: non-django unresolved import may restrict HTTP methods
+def compliant_non_django_import(request):
+    ...
+
 @unknown(["GET", "POST"])
-def compliant_require_http_methods5(request): # Noncompliant
+def compliant_require_http_methods5(request): # Compliant: Unknown decorator might restrict allowed HTTP verbs
     ...
 
 def foo(): ...
 @foo(["GET", "POST"])
-def compliant_require_http_methods6(request): # Noncompliant
+def compliant_require_http_methods6(request): # Compliant
     ...
 
 @require_POST  # Compliant
@@ -43,8 +47,98 @@ def compliant_require_get(request):
 @require_safe  # Compliant
 def compliant_require_safe(request):
   ...
+
+def compliant_method_eq_check(request):  # Compliant: method check in body
+  if request.method == "POST":
+    ...
+
+def compliant_method_eq_check_swapped(request):  # Compliant: operands swapped but still a method check
+  if "POST" == request.method:
+    ...
+
+def compliant_method_in_check(request):  # Compliant: method check in body
+  if request.method in ["GET", "POST"]:
+    ...
+
+def compliant_method_check_and_condition(request):  # Compliant: method check nested in boolean if condition
+  if request.user.is_authenticated and request.method == "POST":
+    ...
+
+def compliant_method_check_parenthesized(request):  # Compliant: comparison wrapped in parentheses
+  if (request.method == "POST"):
+    ...
+
+def compliant_method_check_elif(request):  # Compliant: method check in elif
+  if request.user.is_staff:
+    return "staff"
+  elif request.method == "GET":
+    ...
+
+def compliant_method_check_in_nested_scope(request):  # Compliant: outer request captured by nested scope, method is checked
+  def inner():
+    if request.method == "POST":
+      ...
+  inner()
+
+def noncompliant_nested_function(request, something_else):  # Noncompliant
+  def helper(request):
+    if request.method == "POST":
+      ...
+  helper(something_else)
+
+def noncompliant_lambda(request):  # Noncompliant
+  _ = lambda req: req.method == "POST"
+  ...
+
+def noncompliant1(request):  # Noncompliant
+  ...
+
 @other_decorator
-def sensitive_other_dec(request): # Noncompliant
+def noncompliant_other_dec(request): # Noncompliant
+  ...
+
+@login_required
+def noncompliant_login_required(request):  # Noncompliant
+  ...
+
+@permission_required("app.permission")
+def noncompliant_permission_required(request):  # Noncompliant
+  ...
+
+def noncompliant_method_on_other_var(request):  # Noncompliant
+  _ = request.session
+  ...
+
+def noncompliant_method_on_different_var(request):  # Noncompliant
+  if another.method == "POST":
+    ...
+
+def noncompliant_other_if_eq_check(request):  # Noncompliant
+  if request.user.is_authenticated == True:
+    ...
+
+def noncompliant_method_truthy_check(request):  # Noncompliant
+  if request.method:
+    ...
+
+def noncompliant_method_and_check(request):  # Noncompliant
+  if request.method and request.user.is_authenticated:
+    ...
+
+def noncompliant_method_only_printed(request):  # Noncompliant
+  print(request.method)
+  ...
+
+def noncompliant_method_comparison_not_in_if(request):  # Noncompliant
+  _ = request.method == "POST"
+  ...
+
+def noncompliant_request_used_as_argument(request):  # Noncompliant
+  do_something(request)
+  ...
+
+# Artificial test for Python 2-style tuple parameters: nonTuple() is empty so request.method cannot be checked
+def noncompliant_tuple_param_only((a, b)):  # Noncompliant
   ...
 
 def other(request):
diff --git a/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/flask/views.py b/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/flask/views.py
index 3b84cb6866..ab2ceed779 100644
--- a/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/flask/views.py
+++ b/python-checks/src/test/resources/checks/hotspots/unsafeHttpMethods/flask/views.py
@@ -5,12 +5,12 @@
 methods = Blueprint('methods', __name__)
 
 # 127.0.0.1:5000/methods/sensitive1
-@methods.route('/sensitive1', methods=['GET', 'POST'])  # Noncompliant
+@methods.route('/sensitive1', methods=['GET', 'POST'])  # Compliant - methods explicitly specified
 def sensitive1():
     return Response("Method: " + request.method, 200)
 
 # 127.0.0.1:5000/methods/sensitive1
-@other_routes.route('/sensitive1', methods=['GET', 'POST'])  # Noncompliant
+@other_routes.route('/sensitive1', methods=['GET', 'POST'])  # Compliant - methods explicitly specified
 def sensitive1_other_routes():
     return Response("Method: " + request.method, 200)
 
@@ -56,7 +56,7 @@ def inside_fn():
     methods = Blueprint('methods', __name__)
 
     # 127.0.0.1:5000/methods/sensitive1
-    @methods.route('/sensitive1', methods=['GET', 'POST'])  # Noncompliant
+    @methods.route('/sensitive1', methods=['GET', 'POST'])  # Compliant - methods explicitly specified
     def sensitive1():
         return Response("Method: " + request.method, 200)
 
diff --git a/python-checks/src/test/resources/checks/incompleteComparisonMethods.py b/python-checks/src/test/resources/checks/incompleteComparisonMethods.py
new file mode 100644
index 0000000000..1eed9791b7
--- /dev/null
+++ b/python-checks/src/test/resources/checks/incompleteComparisonMethods.py
@@ -0,0 +1,360 @@
+class OnlyLt:  # Noncompliant {{Add the missing comparison methods or use "functools.total_ordering".}}
+#     ^^^^^^
+    def __lt__(self, other):
+#       ^^^^^^< {{"__lt__" is defined here.}}
+        return self.age < other.age
+
+
+class OnlyGt:  # Noncompliant
+    def __gt__(self, other):
+        return self.value > other.value
+
+
+class OnlyLe:  # Noncompliant
+    def __le__(self, other):
+        return self.value <= other.value
+
+
+class OnlyGe:  # Noncompliant
+    def __ge__(self, other):
+        return self.value >= other.value
+
+
+class TwoMethods:  # Noncompliant
+#     ^^^^^^^^^^
+    def __lt__(self, other):
+#       ^^^^^^< {{"__lt__" is defined here.}}
+        return self.value < other.value
+
+    def __gt__(self, other):
+#       ^^^^^^< {{"__gt__" is defined here.}}
+        return self.value > other.value
+
+
+class ThreeMethods:  # Noncompliant
+    def __lt__(self, other):
+        return self.value < other.value
+
+    def __le__(self, other):
+        return self.value <= other.value
+
+    def __gt__(self, other):
+        return self.value > other.value
+
+
+class EqPlusOneLt:  # Noncompliant
+    def __eq__(self, other):
+        return self.id == other.id
+
+    def __lt__(self, other):
+        return self.id < other.id
+
+
+class WithUnrelated:  # Noncompliant
+    def __len__(self):
+        return 0
+
+    def __lt__(self, other):
+        return len(self) < len(other)
+
+
+class OuterWithInner:
+    class Inner:  # Noncompliant
+        def __lt__(self, other):
+            return self.x < other.x
+
+
+class WithStaticMethod:  # Noncompliant
+    @staticmethod
+    def __lt__(other):
+        return False
+
+
+# A non-functools decorator does not suppress the rule
+def my_ordering(cls):
+    return cls
+
+@my_ordering
+class WithNonFunctoolsDecorator:  # Noncompliant
+    def __lt__(self, other):
+        return self.x < other.x
+
+
+# Compliant: @total_ordering from functools
+from functools import total_ordering
+
+@total_ordering
+class CompliantWithImport:
+    def __eq__(self, other):
+        return self.age == other.age
+
+    def __lt__(self, other):
+        return self.age < other.age
+
+
+# Compliant: @functools.total_ordering (qualified)
+import functools
+
+@functools.total_ordering
+class CompliantQualified:
+    def __eq__(self, other):
+        return self.degrees == other.degrees
+
+    def __lt__(self, other):
+        return self.degrees < other.degrees
+
+
+# Compliant: @ft.total_ordering via aliased import
+import functools as ft
+
+@ft.total_ordering
+class CompliantAlias:
+    def __eq__(self, other):
+        return self.x == other.x
+
+    def __lt__(self, other):
+        return self.x < other.x
+
+
+class AllFourMethods:
+    def __lt__(self, other):
+        return self.value < other.value
+
+    def __le__(self, other):
+        return self.value <= other.value
+
+    def __gt__(self, other):
+        return self.value > other.value
+
+    def __ge__(self, other):
+        return self.value >= other.value
+
+
+class NoOrderingMethods:
+    def __eq__(self, other):
+        return self.x == other.x
+
+    def __ne__(self, other):
+        return self.x != other.x
+
+
+class EmptyClass:
+    pass
+
+
+class OuterCompliant:
+    @total_ordering
+    class Inner:
+        def __eq__(self, other):
+            return self.x == other.x
+
+        def __lt__(self, other):
+            return self.x < other.x
+
+
+class WithInnerFunction:  # Noncompliant
+    def __lt__(self, other):
+        def helper():
+            pass
+        return self.x < other.x
+
+
+class ThreeMethodsWithGe:  # Noncompliant
+    def __lt__(self, other):
+        return self.value < other.value
+
+    def __gt__(self, other):
+        return self.value > other.value
+
+    def __ge__(self, other):
+        return self.value >= other.value
+
+
+@my_ordering
+@total_ordering
+class MultipleDecoratorsCompliant:
+    def __eq__(self, other):
+        return self.x == other.x
+
+    def __lt__(self, other):
+        return self.x < other.x
+
+
+@total_ordering
+@my_ordering
+class TotalOrderingFirstCompliant:
+    def __eq__(self, other):
+        return self.x == other.x
+
+    def __lt__(self, other):
+        return self.x < other.x
+
+
+class ParentWithAllFour:
+    def __lt__(self, other):
+        return self.value < other.value
+
+    def __le__(self, other):
+        return self.value <= other.value
+
+    def __gt__(self, other):
+        return self.value > other.value
+
+    def __ge__(self, other):
+        return self.value >= other.value
+
+
+class ChildDefiningOnlyLt(ParentWithAllFour):  # Noncompliant
+    def __lt__(self, other):
+        return self.value < other.value
+
+
+@my_ordering
+@my_ordering
+class TwoNonFunctoolsDecorators:  # Noncompliant
+    def __lt__(self, other):
+        return self.x < other.x
+
+
+# Compliant: __lt__ and __gt__ defined as lambda assignments, __le__ and __ge__ as `def`.
+# Real-world example: nltk/probability.py (FreqDist).
+class MixedDefAndLambda:
+    def __le__(self, other):
+        return self.value <= other.value
+
+    def __ge__(self, other):
+        return self.value >= other.value
+
+    __lt__ = lambda self, other: self <= other and not self.value == other.value
+    __gt__ = lambda self, other: self >= other and not self.value == other.value
+
+
+# Compliant: one `def`-defined method and three lambda-assigned methods.
+# Real-world example: nltk/tree/tree.py (Tree).
+class OneDefThreeLambdas:
+    def __lt__(self, other):
+        return self.value < other.value
+
+    __gt__ = lambda self, other: not (self < other or self.value == other.value)
+    __le__ = lambda self, other: self < other or self.value == other.value
+    __ge__ = lambda self, other: not self < other
+
+
+# Compliant: all four methods defined via assignments (e.g. function references or partials).
+def _lt(self, other): return self.value < other.value
+def _le(self, other): return self.value <= other.value
+def _gt(self, other): return self.value > other.value
+def _ge(self, other): return self.value >= other.value
+
+class AllFourViaAssignments:
+    __lt__ = _lt
+    __le__ = _le
+    __gt__ = _gt
+    __ge__ = _ge
+
+
+# Compliant: annotated assignments with lambdas count toward the four.
+from typing import Callable
+
+class AnnotatedLambdaAssignments:
+    __lt__: Callable = lambda self, other: self.value < other.value
+    __le__: Callable = lambda self, other: self.value <= other.value
+    __gt__: Callable = lambda self, other: self.value > other.value
+    __ge__: Callable = lambda self, other: self.value >= other.value
+
+
+# Only one distinct ordering method name even with a duplicate `def` and lambda — should raise.
+# The `def` definition is collected first, so it carries the secondary location.
+class OneDistinctNameWithDuplicates:  # Noncompliant
+#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    def __lt__(self, other):
+#       ^^^^^^< {{"__lt__" is defined here.}}
+        return self.value < other.value
+
+    __lt__ = lambda self, other: self.value < other.value
+
+
+# Duplicate `__lt__` definitions — three distinct names total — should still raise.
+# Only the first occurrence of `__lt__` carries a secondary location.
+class DuplicateLtMissingGe:  # Noncompliant
+#     ^^^^^^^^^^^^^^^^^^^^
+    def __lt__(self, other):
+#       ^^^^^^< {{"__lt__" is defined here.}}
+        return self.value < other.value
+
+    def __lt__(self, other):
+        return self.value < other.value
+
+    def __le__(self, other):
+#       ^^^^^^< {{"__le__" is defined here.}}
+        return self.value <= other.value
+
+    def __gt__(self, other):
+#       ^^^^^^< {{"__gt__" is defined here.}}
+        return self.value > other.value
+
+
+# Compliant: duplicate `__lt__` definitions plus all four distinct names — must not raise.
+class DuplicateLtAllFourPresent:
+    def __lt__(self, other):
+        return self.value < other.value
+
+    def __lt__(self, other):
+        return self.value < other.value
+
+    def __le__(self, other):
+        return self.value <= other.value
+
+    def __gt__(self, other):
+        return self.value > other.value
+
+    def __ge__(self, other):
+        return self.value >= other.value
+
+
+# Known FP: rule does not consider comparison methods inherited from parent classes.
+# Real-world example: nltk/tree/probabilistic.py (ProbabilisticTree) overrides only __lt__
+# while inheriting __gt__/__le__/__ge__ as lambdas from its parent — all four comparisons
+# are consistent at runtime, but the rule sees only one method in the subclass body.
+# Tracked as a follow-up of SONARPY-3972.
+class SubclassOverridingLtWithLambdaParent(MixedDefAndLambda):  # Noncompliant
+    def __lt__(self, other):
+        return self.value < other.value
+
+
+# Class-body assignments that are not single-name targets must not affect detection.
+# Chained assignments, tuple unpacking, and attribute targets exercise the early-return
+# branches in the assignment-target name extraction.
+class _Holder:
+    attr = 0
+
+class WithUnusualAssignments:
+    a = b = 10
+    x, y = 1, 2
+    _Holder.attr = 5
+    _Holder.annotated_attr: int = 5
+
+    def __lt__(self, other):
+        return self.value < other.value
+
+    def __le__(self, other):
+        return self.value <= other.value
+
+    def __gt__(self, other):
+        return self.value > other.value
+
+    def __ge__(self, other):
+        return self.value >= other.value
+
+
+# Annotated assignment without an assigned value: must be ignored (treated as no ordering method).
+class AnnotatedWithoutValue:
+    __lt__: Callable
+
+
+# Annotated assignment with a non-ordering method name: must not affect detection.
+class AnnotatedNonOrdering:  # Noncompliant
+    counter: int = 0
+
+    def __lt__(self, other):
+        return self.value < other.value
diff --git a/python-checks/src/test/resources/checks/inconsistentTupleReturn.py b/python-checks/src/test/resources/checks/inconsistentTupleReturn.py
new file mode 100644
index 0000000000..cd5e555fd0
--- /dev/null
+++ b/python-checks/src/test/resources/checks/inconsistentTupleReturn.py
@@ -0,0 +1,339 @@
+# Tests: noncompliant cases
+
+
+def calculate_stats(numbers): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#   ^^^^^^^^^^^^^^^
+    if not numbers:
+        return (0,)
+#       ^^^^^^^^^^^< {{Returns a 1-tuple.}}
+    total = sum(numbers)
+    average = total / len(numbers)
+    return (total, average)
+#   ^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+
+
+def early_guard(x): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#   ^^^^^^^^^^^
+    if x < 0:
+        return (x,)
+#       ^^^^^^^^^^^< {{Returns a 1-tuple.}}
+    result = x * 2
+    extra = x + 1
+    return (x, result, extra)
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 3-tuple.}}
+
+
+def classify_value(x): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#   ^^^^^^^^^^^^^^
+    if x > 0:
+        return (x, "positive", True)
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 3-tuple.}}
+    elif x < 0:
+        return (x, "negative", False)
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 3-tuple.}}
+    else:
+        return (x,)
+#       ^^^^^^^^^^^< {{Returns a 1-tuple.}}
+
+
+def resolve_address(host, port, secure): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#   ^^^^^^^^^^^^^^^
+    if secure:
+        return (host, port, "https")
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 3-tuple.}}
+    return (host, port)
+#   ^^^^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+
+
+# Class method with inconsistent returns
+class DataProcessor:
+    def extract(self, data): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#       ^^^^^^^
+        if not data:
+            return (None, 0)
+#           ^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+        value = data[0]
+        count = len(data)
+        label = str(value)
+        return (value, count, label)
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 3-tuple.}}
+
+
+# Async function with inconsistent returns
+async def fetch_resource(url, timeout): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#         ^^^^^^^^^^^^^^
+    if timeout <= 0:
+        return (url, "error")
+#       ^^^^^^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+    content = "data"
+    status = 200
+    latency = 0.1
+    return (url, content, status, latency)
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 4-tuple.}}
+
+
+# Implicit tuple syntax vs explicit tuple syntax
+def implicit_vs_explicit(items): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#   ^^^^^^^^^^^^^^^^^^^^
+    for i, item in enumerate(items):
+        if item == 0:
+            return i, item
+#           ^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+    return (len(items), items[-1], "last")
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 3-tuple.}}
+
+
+# Try/except with inconsistent returns
+def safe_divide(a, b): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#   ^^^^^^^^^^^
+    try:
+        result = a / b
+        return (result, None)
+#       ^^^^^^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+    except ZeroDivisionError as e:
+        return (None, str(e), True)
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 3-tuple.}}
+
+
+# Multiple branches, one outlier
+def parse_config(config): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#   ^^^^^^^^^^^^
+    if "host" not in config:
+        return ("localhost", 8080)
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+    host = config["host"]
+    port = config.get("port", 80)
+    if "user" in config:
+        return (host, port, config["user"])
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 3-tuple.}}
+    return (host, port)
+#   ^^^^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+
+
+# Loop body with inconsistent returns
+def find_pair(items, target): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#   ^^^^^^^^^
+    for i, item in enumerate(items):
+        if item == target:
+            return (i, item)
+#           ^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+        if item > target:
+            return (i,)
+#           ^^^^^^^^^^^< {{Returns a 1-tuple.}}
+    return (len(items), None)
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+
+
+# ##############################################################################
+# Compliant patterns
+# ##############################################################################
+
+
+# All returns produce 2-tuples — consistent
+def calculate_stats_fixed(numbers):
+    if not numbers:
+        return (0, 0)
+    total = sum(numbers)
+    average = total / len(numbers)
+    return (total, average)
+
+
+# Single return statement — no inconsistency possible
+def make_pair(a, b):
+    return (a, b)
+
+
+# Only one tuple-returning return statement; the other returns None
+def find_element(items, target):
+    for i, item in enumerate(items):
+        if item == target:
+            return (i, item)
+    return None
+
+
+# Returns a scalar on all paths — rule does not apply (no tuple literals)
+def double(x):
+    if x > 0:
+        return x * 2
+    return 0
+
+
+# Returns a list on both paths — rule does not apply (list is not a tuple)
+def get_items(flag):
+    if flag:
+        return [1, 2, 3]
+    return [4, 5]
+
+
+# Empty tuple consistently — no inconsistency
+def always_empty(condition):
+    if condition:
+        return ()
+    return ()
+
+
+# Generator function — rule does not apply
+def generate_pairs(items):
+    for i, item in enumerate(items):
+        yield (i, item)
+
+
+# Function with no return statements — no issue
+def do_nothing():
+    pass
+
+
+# NamedTuple usage — returns a call expression, not a raw tuple literal
+from typing import NamedTuple
+
+
+class Stats(NamedTuple):
+    total: float
+    average: float
+
+
+def calculate_named_stats(numbers):
+    if not numbers:
+        return Stats(total=0, average=0)
+    total = sum(numbers)
+    average = total / len(numbers)
+    return Stats(total=total, average=average)
+
+
+# Async function with consistent 2-tuples — no issue
+async def fetch_resource_ok(url, timeout):
+    if timeout <= 0:
+        return (url, "timeout")
+    content = "data"
+    return (url, content)
+
+
+# Nested function definitions — outer has consistent returns; inner is flagged independently
+def outer_consistent(x):
+    def inner_inconsistent(y): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#       ^^^^^^^^^^^^^^^^^^
+        if y > 0:
+            return (y,)
+#           ^^^^^^^^^^^< {{Returns a 1-tuple.}}
+        return (y, y * 2)
+#       ^^^^^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+
+    return (x, inner_inconsistent)
+
+
+# Bare return plus one tuple return — only one tuple return, no inconsistency
+def maybe_tuple(x):
+    if x is None:
+        return
+    return (x, x + 1)
+
+
+# Variable assigned a tuple and returned — rule only detects literal tuple syntax
+# at the return site, so this is a false negative (accepted limitation)
+def tuple_via_variable(a, b, c):
+    t2 = (a, b)
+    t3 = (a, b, c)
+    if a > 0:
+        return t2
+    return t3
+
+
+# Dynamic tuple construction — accepted false negative
+def tuple_via_constructor(values):
+    if values:
+        return tuple(values)
+    return tuple(range(3))
+
+
+# Star-unpacking in tuple — length is dynamic, so rule does not flag this
+def star_tuple(prefix, value):
+    if prefix:
+        return (*prefix, value)
+    return (value,)
+
+
+# ##############################################################################
+# Edge cases
+# ##############################################################################
+
+
+# No arguments — function has no returns at all
+def no_body():
+    ...
+
+
+# Only non-tuple returns — rule does not apply even though lengths would differ
+# if interpreted as tuples
+def non_tuple_paths(x):
+    if x > 0:
+        return x
+    elif x < 0:
+        return -x
+    return 0
+
+
+# Single tuple return alongside multiple non-tuple returns — only one tuple
+def mixed_non_tuple_and_one_tuple(x):
+    if x > 100:
+        return None
+    if x < 0:
+        return -1
+    return (x, x * 2)
+
+
+# Lambda inside function — lambda returns must not be collected
+def outer_with_lambda(items):
+    transform = lambda x: (x,) if x > 0 else (x, x - 1)
+    if items:
+        return (items[0], len(items))
+    return (None, 0)
+
+
+# Nested function is itself noncompliant; outer is compliant — inner's returns
+# must not pollute the outer function's analysis
+def outer_compliant_inner_noncompliant(data):
+    def inner(x): # Noncompliant {{Refactor this function to always return tuples of the same length.}}
+#       ^^^^^
+        if x:
+            return (x,)
+#           ^^^^^^^^^^^< {{Returns a 1-tuple.}}
+        return (x, 0)
+#       ^^^^^^^^^^^^^< {{Returns a 2-tuple.}}
+    result = inner(data)
+    if data:
+        return (data, True)
+    return (None, False)
+
+
+# Implicit tuple with single element — `return x,` is a 1-tuple
+def implicit_single_element(x):
+    if x > 0:
+        return x,
+    return x,
+
+
+# Try/except/else/finally — only tuple returns matter, bare returns are ignored
+def try_with_bare_return(x):
+    try:
+        result = 1 / x
+        return (result, "ok")
+    except ZeroDivisionError:
+        return
+    finally:
+        pass
+
+
+# Multiple return values all the same length using implicit syntax
+def implicit_consistent(a, b, c):
+    if a > 0:
+        return a, b
+    if b > 0:
+        return b, c
+    return c, a
+
+
+# Star-unpacking in implicit tuple — length is dynamic, so rule does not flag this
+def star_implicit_tuple(prefix, value):
+    if prefix:
+        return *prefix, value
+    return (value,)
diff --git a/python-checks/src/test/resources/checks/incorrectParameterDatetimeConstructorsCheck.py b/python-checks/src/test/resources/checks/incorrectParameterDatetimeConstructorsCheck.py
index b7c5d724d3..99e3430e09 100644
--- a/python-checks/src/test/resources/checks/incorrectParameterDatetimeConstructorsCheck.py
+++ b/python-checks/src/test/resources/checks/incorrectParameterDatetimeConstructorsCheck.py
@@ -4,6 +4,7 @@ def compliant_examples():
     datetime.time(12, 30, 0, 0)
     datetime.date(2024, 3, 1)
     datetime.datetime(2024, 3, 1, 12, 30, 0, 0)
+    datetime.date(9223372036854775808, 1, 1)  # Compliant (year literal does not parse to long)
 
 def non_compliant_examples():
     datetime.date(2024, 3, 32) # Noncompliant {{Provide a correct value for the `day` parameter.}}
diff --git a/python-checks/src/test/resources/checks/infiniteRecursion.py b/python-checks/src/test/resources/checks/infiniteRecursion.py
index 2d39808e72..090f48c6fd 100644
--- a/python-checks/src/test/resources/checks/infiniteRecursion.py
+++ b/python-checks/src/test/resources/checks/infiniteRecursion.py
@@ -353,7 +353,7 @@ def match_statement_no_fp(value):
   return no_fp_with_match(value + 1)
 
 
-def match_statement_fn(value):  # FN, "case x" will always match
+def match_statement_fn(value):  # Noncompliant
   match value:
     case x:
       return match_statement_fn(value + 1)
diff --git a/python-checks/src/test/resources/checks/instanceMethodSelfAsFirst.py b/python-checks/src/test/resources/checks/instanceMethodSelfAsFirst.py
index 5112e600fa..72cbfcc242 100644
--- a/python-checks/src/test/resources/checks/instanceMethodSelfAsFirst.py
+++ b/python-checks/src/test/resources/checks/instanceMethodSelfAsFirst.py
@@ -182,3 +182,39 @@ def used_as_decorator_call(method):  # OK
 
 @used_as_decorator_call()
 def decorated(self): ...
+
+from enum import Enum, auto
+import enum
+
+# Do not raise on _generate_next_value_ in Enum subclasses
+class MyAutoName(Enum):
+    def _generate_next_value_(name, start, count, last_values):  # OK
+        return name
+
+class Animal(Enum):
+    def _generate_next_value_(name, start, count, last_values):  # OK
+        return name.lower()
+
+    DOG = auto()
+    CAT = auto()
+
+class UpperCaseEnum(enum.Enum):
+    def _generate_next_value_(name, start, count, last_values):  # OK
+        return name.upper()
+
+class NotAnEnum:
+    def _generate_next_value_(name, start, count, last_values):  # Noncompliant
+        return name
+
+class EnumWithOtherMethod(Enum):
+    def regular_method(arg):  # Noncompliant
+        pass
+
+# Indirect Enum subclass: _generate_next_value_ should also be exempt
+class BaseAutoEnum(Enum):
+    def _generate_next_value_(name, start, count, last_values):  # OK
+        return name.upper()
+
+class DerivedAutoEnum(BaseAutoEnum):
+    def _generate_next_value_(name, start, count, last_values):  # OK
+        return name.lower()
diff --git a/python-checks/src/test/resources/checks/invariantReturn.py b/python-checks/src/test/resources/checks/invariantReturn.py
index ab98537270..14408417df 100644
--- a/python-checks/src/test/resources/checks/invariantReturn.py
+++ b/python-checks/src/test/resources/checks/invariantReturn.py
@@ -433,15 +433,56 @@ def f_raise_is_not_a_return(a, b):
         raise b
     return b
 
-def f_function_exit_through_raise_should_be_ignored(a, b, c): # Noncompliant
-#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+def f_function_exit_through_raise_prevents_reporting(a, b, c):
     if a:
         return b
-#       ^^^^^^^^<
     if c:
         raise
     return b
-#   ^^^^^^^^<
+
+def f_early_return_with_raise_guard(already_valid, invalid, obj):
+    if already_valid:
+        return obj
+    if invalid:
+        raise ValueError()
+    return obj
+
+def f_unreachable_raise_does_not_prevent_reporting(a, b): # Noncompliant
+    if a:
+        return b
+    return b
+    raise ValueError()
+
+def f_raise_in_try_with_finally(early, invalid, value):
+    if early:
+        return value
+    try:
+        if invalid:
+            raise ValueError()
+    finally:
+        pass
+    return value
+
+def f_raise_in_try_with_except(early, invalid, value):
+    if early:
+        return value
+    try:
+        if invalid:
+            raise ValueError()
+    except TypeError:
+        cleanup()
+    return value
+
+def f_unreachable_raise_before_finally_does_not_prevent_reporting(a, b): # Noncompliant
+    try:
+        if a:
+            return b
+        else:
+            return b
+        raise ValueError()
+    finally:
+        pass
+    return b
 
 def f_same_binding_through_multiple_paths(a): # Noncompliant
     d = 3
@@ -529,7 +570,7 @@ def match_statement_no_fp_with_implicit_return(value):  # OK, implicit "None" re
       return 42
 
 
-def match_statement_fn_with_capture(value): # FN, implicit "None" return is unreachable
+def match_statement_fn_with_capture(value): # Noncompliant
   match value:
     case 1:
       return 42
diff --git a/python-checks/src/test/resources/checks/jwtVerification.py b/python-checks/src/test/resources/checks/jwtVerification.py
index d381db0dff..d3e72f2e9a 100644
--- a/python-checks/src/test/resources/checks/jwtVerification.py
+++ b/python-checks/src/test/resources/checks/jwtVerification.py
@@ -1,5 +1,14 @@
 import jwt
 import python_jwt
+from enum import Enum
+
+class AuthIssuer(Enum):
+    ISSUER_A = "issuer1"
+    ISSUER_B = "issuer2"
+
+class NotAnEnum:
+    def __init__(self, value):
+        self.value = value
 
 def jwt_decode_argument(token):
     jwt.decode(token)
@@ -40,6 +49,227 @@ def pyjwt_decode_token_secure_1(token):
 def pyjwt_decode_token_secure_2(token):
     return jwt.decode(token, algorithms="HS256") # Compliant
 
+def peek_then_verify_options_dict(token, keys):
+    unverified = jwt.decode(token, options={"verify_signature": False, "require": ["iss"]}) # Compliant: same token is re-decoded below with real verification
+    issuer = unverified["iss"]
+    key = keys[issuer]
+    return jwt.decode(token, key, algorithms=["HS256"])
+
+def peek_then_verify_options_list(token, keys):
+    unverified = jwt.decode(token, options=[("verify_signature", False), ("require", ["iss"])]) # Compliant: same token is re-decoded below with real verification
+    issuer = unverified["iss"]
+    key = keys[issuer]
+    return jwt.decode(token, key, algorithms=["HS256"])
+
+def peek_then_verify_verify_kwarg(token, keys):
+    unverified = jwt.decode(token, verify=False) # Compliant: same token is re-decoded below with real verification
+    issuer = unverified["iss"]
+    key = keys[issuer]
+    return jwt.decode(token, key, algorithms=["HS256"])
+
+# only token_b is re-verified below, not token_a
+def peek_then_verify_different_variable(token_a, token_b, keys):
+    unverified = jwt.decode(token_a, options={"verify_signature": False}) # Noncompliant
+    key = keys[unverified["iss"]]
+    return jwt.decode(token_b, key, algorithms=["HS256"])
+
+# the later call on the same token is also unverified
+def peek_then_verify_second_call_also_unverified(token, keys):
+    unverified = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = unverified["iss"]
+    key = keys[issuer]
+    return jwt.decode(token, key, algorithms=["HS256"], verify=False) # Noncompliant
+
+def peek_then_verify_unresolvable_token(keys):
+    return jwt.decode(get_token(), options={"verify_signature": False}) # Compliant: token argument isn't a resolvable variable, assume compliant
+
+# real verification below is in a different function, out of scope
+def peek_then_verify_wrong_scope(token, keys):
+    def inner():
+        return jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    def other():
+        return jwt.decode(token, keys["k"], algorithms=["HS256"])
+    return inner(), other()
+
+def issuer_routing_enum_conversion(token: str, verification_key: str) -> AuthIssuer:
+    try:
+        payload = jwt.decode(token, options={"verify_signature": False}) # Compliant: only iss accessed, validated via enum conversion
+    except jwt.DecodeError:
+        raise ValueError("Invalid token format")
+    issuer_string = payload.get("iss")
+    if not issuer_string:
+        raise ValueError("Token missing 'iss' (issuer) claim")
+    try:
+        iss_enum_member = AuthIssuer(issuer_string)
+    except ValueError:
+        raise ValueError(f"Unsupported token issuer: {issuer_string}")
+    return iss_enum_member
+
+def issuer_routing_verify_kwarg(token: str):
+    payload = jwt.decode(token, verify=False) # Compliant: same pattern via the verify= kwarg shape instead of options=
+    issuer = payload.get("iss")
+    if issuer not in {"issuer1", "issuer2"}:
+        raise ValueError("Unsupported token issuer")
+    return issuer
+
+def issuer_routing_set_membership(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Compliant: only iss accessed, validated via set membership
+    issuer = payload.get("iss")
+    if issuer not in {"issuer1", "issuer2"}:
+        raise ValueError("Unsupported token issuer")
+    return issuer
+
+def issuer_routing_dict_lookup(token: str):
+    KEY_BY_ISSUER = {"issuer1": "secret1", "issuer2": "secret2"}
+    payload = jwt.decode(token, options={"verify_signature": False}) # Compliant: only iss accessed, validated via dict lookup
+    issuer = payload["iss"]
+    key = KEY_BY_ISSUER[issuer]
+    return jwt.decode(token, key, algorithms=["HS256"])
+
+def issuer_routing_get_with_default(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Compliant: the "default_issuer" fallback isn't an additional accessed key
+    issuer = payload.get("iss", "default_issuer")
+    if issuer not in {"issuer1", "issuer2", "default_issuer"}:
+        raise ValueError("Unsupported token issuer")
+    return issuer
+
+# an empty dict is never a valid static whitelist - the lookup would always KeyError
+def issuer_routing_empty_dict_lookup(token: str):
+    KEY_BY_ISSUER = {}
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload["iss"]
+    return KEY_BY_ISSUER[issuer]
+
+
+# dict has a non-literal key, not a valid static whitelist
+def issuer_routing_dict_lookup_non_literal_key(token: str, dynamic_key):
+    KEY_BY_ISSUER = {"issuer1": "secret1", dynamic_key: "secret2"}
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload["iss"]
+    return KEY_BY_ISSUER[issuer]
+
+# dict is built with a spread rather than only literal key/value pairs, not a valid static whitelist
+def issuer_routing_dict_lookup_with_spread(token: str, other_dict):
+    KEY_BY_ISSUER = {"issuer1": "secret1", **other_dict}
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload["iss"]
+    return KEY_BY_ISSUER[issuer]
+
+# set contains a non-literal element, not a valid static whitelist
+def issuer_routing_set_with_non_literal_element(token: str, dynamic_issuer):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload.get("iss")
+    if issuer not in {"issuer1", dynamic_issuer}:
+        raise ValueError("Unsupported token issuer")
+    return issuer
+
+# NotAnEnum isn't a declared Enum subclass, so this doesn't count as enum-conversion validation
+def issuer_routing_not_actually_an_enum(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer_string = payload.get("iss")
+    try:
+        wrapped = NotAnEnum(issuer_string)
+    except ValueError:
+        raise ValueError(f"Unsupported token issuer: {issuer_string}")
+    return wrapped
+
+# AuthIssuer(...) is called in scope, but not with the issuer symbol - doesn't count as validating it
+def issuer_routing_enum_call_without_issuer_argument(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload.get("iss")
+    default_issuer = AuthIssuer("issuer1")
+    return issuer, default_issuer
+
+# sub is also read from the payload, so the "only iss" requirement isn't met
+def issuer_routing_disallowed_claim_access(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload.get("iss")
+    subject = payload.get("sub")
+    if issuer not in {"issuer1", "issuer2"}:
+        raise ValueError("Unsupported token issuer")
+    return issuer, subject
+
+# payload itself is returned, not just the iss claim
+def issuer_routing_payload_returned_raw(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload.get("iss")
+    if issuer not in {"issuer1", "issuer2"}:
+        raise ValueError("Unsupported token issuer")
+    return payload
+
+def validate_issuer_elsewhere(issuer):
+    if issuer not in {"issuer1", "issuer2"}:
+        raise ValueError("Unsupported token issuer")
+
+# the whitelist check lives in a sibling function, out of scope for this one
+def issuer_routing_wrong_scope(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload.get("iss")
+    return issuer
+
+# the decode result isn't assigned to a local variable at all, so there's nothing to trace usages of
+def issuer_routing_no_assignment(token: str):
+    return jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+
+# passed to another function rather than only having "iss" read - not a recognized safe usage
+def issuer_routing_payload_passed_to_other_function(token: str, do_something_with):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    return do_something_with(payload)
+
+# the dict subscript in scope doesn't actually use the issuer symbol, so it doesn't count as a whitelist check
+def issuer_routing_unrelated_dict_lookup(token: str, other_key):
+    OTHER_LOOKUP = {"a": "1", "b": "2"}
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload.get("iss")
+    return OTHER_LOOKUP[other_key]
+
+# .get() called with no key argument at all - nothing to classify as the iss claim
+def issuer_routing_get_no_arguments(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload.get()
+    return issuer
+
+# .get() called with a non-literal key - can't tell if it's "iss" or something else
+def issuer_routing_get_non_literal_key(token: str, claim_name):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload.get(claim_name)
+    return issuer
+
+# subscription with a non-literal key - same ambiguity as the .get() case above
+def issuer_routing_subscription_non_literal_key(token: str, claim_name):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    issuer = payload[claim_name]
+    return issuer
+
+# decode result is assigned to a tuple target (a, b = ..., ...), not a single Name
+def issuer_routing_tuple_assignment_target(token: str, other_token):
+    payload, other_payload = jwt.decode(token, options={"verify_signature": False}), jwt.decode(other_token) # Noncompliant
+    return payload, other_payload
+
+def issuer_routing_iss_accessed_inline_no_binding(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Compliant: iss is compared inline against a literal whitelist, never bound to a Name
+    if payload.get("iss") not in {"issuer1", "issuer2"}:
+        raise ValueError("Unsupported token issuer")
+    return True
+
+def issuer_routing_iss_accessed_inline_no_binding_subscription(token: str):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Compliant: same as above but via subscription access
+    if payload["iss"] not in {"issuer1", "issuer2"}:
+        raise ValueError("Unsupported token issuer")
+    return True
+
+# right operand of the inline `in` check isn't a literal collection, so this isn't a static whitelist
+def issuer_routing_iss_accessed_inline_no_binding_dynamic_whitelist(token: str, allowed_issuers):
+    payload = jwt.decode(token, options={"verify_signature": False}) # Noncompliant
+    if payload.get("iss") not in allowed_issuers:
+        raise ValueError("Unsupported token issuer")
+    return True
+
+module_token = "..."
+module_key = "secret"
+module_unverified = jwt.decode(module_token, options={"verify_signature": False}) # Compliant: real verification happens at module scope below
+module_verified = jwt.decode(module_token, module_key, algorithms=["HS256"])
+
 def pyjwt_decode_unverified_header(token):
     return jwt.get_unverified_header(token) # Noncompliant
 
@@ -92,3 +322,113 @@ def get_unverified_header_compliant(token: str, keys):
     key = keys[jku]
     claims = jwt.decode(token, key, algorithms=["HS256"])
     return claims
+
+def get_unverified_header_compliant_get_with_default(token: str):
+    header = jwt.get_unverified_header(token)  # Compliant: the "none" fallback isn't an additional accessed key
+    kid = header.get("kid", "none")
+    return kid
+
+def header_comparison_whole_header(token: str):
+    expected_header = {"alg": "RS256", "typ": "JWT"}
+    received_header = jwt.get_unverified_header(token)  # Compliant: only compared, never used for a decision
+    if expected_header != received_header:
+        raise ValueError("Invalid header")
+    return True
+
+def header_comparison_inline_no_assignment(token: str, expected):
+    if jwt.get_unverified_header(token) == expected:  # Compliant: compared inline, never assigned
+        return True
+    return False
+
+def header_comparison_extracted_value_inline_no_assignment(token: str):
+    if jwt.get_unverified_header(token).get("alg") != "RS256":  # Compliant: extracted value compared inline
+        raise ValueError("Wrong algorithm")
+    return True
+
+def header_comparison_subscription_inline_no_assignment(token: str):
+    if jwt.get_unverified_header(token)["alg"] != "RS256":  # Compliant: extracted value compared inline
+        raise ValueError("Wrong algorithm")
+    return True
+
+def header_comparison_extracted_value(token: str):
+    received_header = jwt.get_unverified_header(token)  # Compliant: extracted value only compared
+    if received_header.get("alg") != "RS256":
+        raise ValueError("Wrong algorithm")
+    return True
+
+def header_comparison_subscription(token: str):
+    received_header = jwt.get_unverified_header(token)  # Compliant: extracted value only compared
+    if received_header["alg"] != "RS256":
+        raise ValueError("Wrong algorithm")
+    return True
+
+def header_comparison_multiple_safe_usages(token: str):
+    expected_header = {"alg": "RS256", "typ": "JWT"}
+    received_header = jwt.get_unverified_header(token)  # Compliant: every usage is a safe comparison
+    if expected_header != received_header:
+        raise ValueError("Invalid header")
+    if received_header == expected_header:
+        return True
+    if received_header.get("alg") != "RS256":
+        raise ValueError("Wrong algorithm")
+    return True
+
+
+# header is also returned raw below - comparing it once doesn't make the other, unsafe usage safe
+def header_comparison_mixed_with_unsafe_use(token: str) -> Dict[str, str]:
+    header = jwt.get_unverified_header(token)  # Noncompliant
+    if header.get("alg") != "RS256":
+        raise ValueError("Wrong algorithm")
+    return header
+
+def algorithm_validated_then_used(token: str, key):
+    header = jwt.get_unverified_header(token)  # Compliant: alg is validated against an allowlist before use
+    alg = header.get("alg")
+    if alg not in ["RS256", "ES256"]:
+        raise ValueError("Unsupported algorithm")
+    return jwt.decode(token, key, algorithms=[alg])
+
+def algorithm_validated_then_used_subscription(token: str, key):
+    header = jwt.get_unverified_header(token)  # Compliant: alg is validated against an allowlist before use
+    alg = header["alg"]
+    if alg not in ("RS256", "ES256"):
+        raise ValueError("Unsupported algorithm")
+    return jwt.decode(token, key, algorithms=[alg])
+
+# alg is used to decode BEFORE it's validated - the guard doesn't protect this decode call
+def algorithm_used_before_validated(token: str, key):
+    header = jwt.get_unverified_header(token)  # Noncompliant
+    alg = header.get("alg")
+    payload = jwt.decode(token, key, algorithms=[alg])
+    if alg not in ["RS256", "ES256"]:
+        raise ValueError("Unsupported algorithm")
+    return payload
+
+
+# alg is used directly in algorithms=[...] without ever being validated against an allowlist
+def algorithm_used_without_validation(token: str, key):
+    header = jwt.get_unverified_header(token)  # Noncompliant
+    alg = header.get("alg")
+    return jwt.decode(token, key, algorithms=[alg])
+
+def validate_alg_elsewhere(alg):
+    if alg not in ["RS256"]:
+        raise ValueError("Unsupported algorithm")
+
+# the allowlist guard lives in a sibling function, out of scope for this one
+def algorithm_validated_wrong_scope(token: str, key):
+    header = jwt.get_unverified_header(token)  # Noncompliant
+    alg = header.get("alg")
+    return jwt.decode(token, key, algorithms=[alg])
+
+def algorithm_validated_then_used_bare_name(token: str, key):
+    header = jwt.get_unverified_header(token)  # Compliant: alg is validated before being passed as a bare algorithms= value
+    alg = header.get("alg")
+    if alg not in ["RS256", "ES256"]:
+        raise ValueError("Unsupported algorithm")
+    return jwt.decode(token, key, algorithms=alg)
+
+# alg is never bound to a simple name (used inline), so it can't be tracked for validation
+def algorithm_extracted_inline_no_validation(token: str, key):
+    header = jwt.get_unverified_header(token)  # Noncompliant
+    return jwt.decode(token, key, algorithms=[header.get("alg")])
diff --git a/python-checks/src/test/resources/checks/listIterableFirstElement.py b/python-checks/src/test/resources/checks/listIterableFirstElement.py
new file mode 100644
index 0000000000..e0b5de285d
--- /dev/null
+++ b/python-checks/src/test/resources/checks/listIterableFirstElement.py
@@ -0,0 +1,51 @@
+
+def noncompliant_materialize_first(users):
+    return list(users)[0]  # Noncompliant {{Replace "list(...)[0]" with "next(iter(...))" to avoid materializing the entire iterable.}}
+#          ^^^^
+
+
+def compliant_next_iter(users):
+    return next(iter(users))
+
+def compliant_nonzero_index(items):
+    return list(items)[1]
+
+def compliant_float_subscript(items):
+    return list(items)[0.0]
+
+def compliant_float_scientific_zero(items):
+    return list(items)[0e0]
+
+def compliant_complex_subscript(items):
+    return list(items)[0j]
+
+def compliant_negative_index(items):
+    return list(items)[-1]
+
+def compliant_slice(items):
+    return list(items)[0:1]
+
+def compliant_tuple_subscript(items):
+    return list(items)[0, 1]
+
+def compliant_starred(args):
+    return list(*args)[0]
+
+def compliant_multiple_args():
+    return list([], [])[0]
+
+def compliant_direct_index(items):
+    return items[0]
+
+def compliant_two_step_list(items):
+    all_items = list(items)
+    return all_items[0]  # out of scope: [0] applies to a Name, not to list(...) call
+
+def compliant_shadowed_list(items):
+    list = lambda x: x
+    return list(items)[0]
+
+
+def fn_subscript_not_literal_zero(items):
+    zero = 0
+    return list(items)[zero]  # FN: subscript must be numeric literal 0
diff --git a/python-checks/src/test/resources/checks/localVariableAndParameterNameIncompatibility.py b/python-checks/src/test/resources/checks/localVariableAndParameterNameIncompatibility.py
index 3e63fc5587..c4a37f4a54 100644
--- a/python-checks/src/test/resources/checks/localVariableAndParameterNameIncompatibility.py
+++ b/python-checks/src/test/resources/checks/localVariableAndParameterNameIncompatibility.py
@@ -91,6 +91,40 @@ class MyClass:
     MyClassAlias = MyClass  # OK
     MyTypeVariable: type = unknown_call()  # Noncompliant
 
+def builtin_type_assignments(role, roles):
+    RoleType = type(role)
+    OptionalRoleType = type(roles[0]) if roles else None
+    ParenthesizedRoleType = (type(role))
+    BadName = wrapper(type(role))  # Noncompliant
+
+def annotated_builtin_type_assignments(role, roles):
+    AnnotatedRoleType: type = type(role)
+    AnnotatedOptionalRoleType: type | None = type(roles[0]) if roles else None
+    AnnotatedBadName: type = wrapper(type(role))  # Noncompliant
+
+def walrus_builtin_type_assignments(role):
+    if (WalrusRoleType := type(role)):
+        pass
+    while (WalrusBadName := wrapper(type(role))):  # Noncompliant
+        pass
+
+def conditional_builtin_type_assignments(role, fallback, cond, roles):
+    BothBranchesType = type(role) if cond else type(fallback)
+    NestedType = type(role) if cond else type(fallback) if roles else None
+    ReversedType = None if not roles else type(roles[0])
+    ParenthesizedNoneType = type(role) if cond else (None)
+    BothBranchesNone = None if cond else None  # Noncompliant
+    MixedBranches = type(role) if cond else 5  # Noncompliant
+
+def reassigned_parameter(BadParam, role):  # Noncompliant
+    BadParam = type(role)
+
+def shadowed_type_assignment():
+    def type(value):
+        return value
+
+    BadName = type("role")  # Noncompliant
+
 def ml_names():
     X = [1, 2, 3]
     Y = [0, 1, 0]
@@ -145,3 +179,31 @@ def execute(self):
 class DerivedLongerSignature(BaseShortSignature):
     def execute(self, ExtraParam):  # Noncompliant
         pass
+
+
+import marimo
+
+app = marimo.App()
+
+
+@app.cell
+def _():
+    TSHIRT_ORDER = ["XS", "S", "M", "L", "XL", "XXL"]
+    return TSHIRT_ORDER,
+
+
+@app.cell
+def _(TSHIRT_ORDER):
+    filtered = [size for size in TSHIRT_ORDER if size != "XXL"]
+    return filtered,
+
+
+@app.cell(hide_code=True)
+def _(API_KEY, DB_CONFIG):
+    connection_string = f"host={DB_CONFIG['host']}?key={API_KEY}"
+    return connection_string,
+
+
+@app.function
+def helper(INPUT_DATA):
+    return INPUT_DATA
diff --git a/python-checks/src/test/resources/checks/loggingBestPractices.py b/python-checks/src/test/resources/checks/loggingBestPractices.py
new file mode 100644
index 0000000000..00dba19f6d
--- /dev/null
+++ b/python-checks/src/test/resources/checks/loggingBestPractices.py
@@ -0,0 +1,131 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+user = "Maria"
+count = 42
+
+
+# ==== Eager string formatting: f-string ====
+
+logging.info(f"{user} - Something happened")  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+logger.info(f"{user} logged in")  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+
+
+# ==== Eager string formatting: .format() ====
+
+logging.debug("{} - Something happened".format(user))  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+logger.debug("{}".format(user))  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+
+
+# ==== Eager string formatting: % operator ====
+
+logging.warning("%s - Something happened" % user)  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+logger.warning("%s err" % user)  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+
+
+# ==== Eager string formatting: + concatenation ====
+
+logging.error("Error: " + user)  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+logging.critical(user + " triggered critical")  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+logger.error("User: " + user + " failed")  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+
+
+# ==== Deprecated warn method ====
+
+logging.warn("Something happened")  # Noncompliant {{Use "warning" instead of the deprecated "warn" method.}}
+logger.warn("Something happened")  # Noncompliant {{Use "warning" instead of the deprecated "warn" method.}}
+
+
+# ==== Extra attribute name collisions ====
+
+logging.info("msg", extra={"name": "override"})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+logging.info("msg", extra={"message": "val"})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+logging.info("msg", extra={"levelname": "DEBUG"})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+logging.info("msg", extra={"filename": "app.py"})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+logging.info("msg", extra={"lineno": 42})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+logging.info("msg", extra={"thread": 1})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+logging.info("msg", extra={"process": 2})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+logging.info("msg", extra={"exc_text": "custom"})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+logging.info("msg", extra={"stack_info": "custom"})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+logging.info("msg", extra={"asctime": "custom"})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+
+
+# ==== logging.exception ====
+
+logging.exception(f"{user} failed")  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+logger.exception("Error: " + user)  # Noncompliant {{Pass formatting arguments to the logging call instead of pre-formatting the message string.}}
+logging.exception("msg", extra={"name": "override"})  # Noncompliant {{Remove or rename this key; it overrides a built-in LogRecord attribute.}}
+
+
+# ==== Compliant: lazy formatting ====
+
+logging.info("%s - Something happened", user)
+logging.debug("User %s did %d actions", user, count)
+logging.warning("Count is %d", count)
+logger.info("%s logged in", user)
+logger.debug("User %s did %d actions", user, count)
+logger.error("Error for %s", user)
+logger.critical("Critical for %s", user)
+
+
+# ==== Compliant: plain string messages ====
+
+logging.info("Application started")
+logging.error("An unexpected error occurred")
+logger.warning("Low memory warning")
+
+
+# ==== Compliant: non-deprecated methods ====
+
+logging.warning("Something happened")
+logger.warning("Something happened")
+
+
+# ==== Compliant: valid format specifiers ====
+
+logging.info("Value: %s", user)
+logging.debug("Count: %d, ratio: %f", count, 3.14)
+logging.info("Hex: %x, oct: %o", count, count)
+logging.debug("Repr: %r", user)
+logging.info("100%% done")
+
+
+# ==== Compliant: extra with custom (non-reserved) keys ====
+
+logging.info("Request processed", extra={"request_id": "abc123", "duration_ms": 42})
+logger.info("User action", extra={"user_id": 99, "action": "login"})
+
+
+# ==== Compliant: exc_info keyword argument ====
+
+try:
+    pass
+except Exception:
+    logging.error("Something failed", exc_info=True)
+
+
+# ==== Compliant: no positional arguments ====
+
+logging.info()
+logging.debug("Static message with no format args")
+
+
+# ==== Compliant: extra with ** unpacking (FN accepted) ====
+
+extra_data = {"name": "override"}
+logging.info("msg", extra=extra_data)
+logging.info("msg", extra={**extra_data})
+
+
+# ==== Compliant: + with non-string operands ====
+
+a = 1
+b = 2
+logging.info("%d", a + b)
+logging.info("%d", a % b)
+
+
+# ==== Compliant: empty f-string (no formatted expressions) ====
+
+logging.info(f"static message")
diff --git a/python-checks/src/test/resources/checks/loggingException.py b/python-checks/src/test/resources/checks/loggingException.py
new file mode 100644
index 0000000000..213c34e0e4
--- /dev/null
+++ b/python-checks/src/test/resources/checks/loggingException.py
@@ -0,0 +1,320 @@
+import logging
+import sys
+import traceback
+
+logger = logging.getLogger(__name__)
+
+
+# ---------- Noncompliant: exc_info=True ----------
+
+def noncompliant_with_exc_info_true():
+    try:
+        raise RuntimeError("runtime error")
+    except RuntimeError:
+        logging.error("Runtime error occurred", exc_info=True)  # Noncompliant {{Use "logging.exception()" instead.}}
+
+
+def noncompliant_named_logger_exc_info_true():
+    try:
+        risky()
+    except Exception:
+        logger.error("Named logger error", exc_info=True)  # Noncompliant
+
+
+def noncompliant_exc_info_true_with_as():
+    try:
+        risky()
+    except Exception as ex:
+        logging.error("Error", exc_info=True)  # Noncompliant
+
+
+# ---------- Noncompliant: exception object referenced in args ----------
+
+def noncompliant_fstring_reference():
+    try:
+        risky()
+    except Exception as ex:
+        logging.error(f"Error: {ex}")  # Noncompliant {{Use "logging.exception()" instead.}}
+
+
+def noncompliant_percent_s_positional():
+    try:
+        risky()
+    except ValueError as ex:
+        logging.error("Error: %s", ex)  # Noncompliant
+
+
+def noncompliant_percent_formatting():
+    try:
+        risky()
+    except ValueError as ex:
+        logging.error("Error: %s" % ex)  # Noncompliant
+
+
+def noncompliant_format_method():
+    try:
+        risky()
+    except ValueError as ex:
+        logging.error("Error: {}".format(ex))  # Noncompliant
+
+
+def noncompliant_direct_pass():
+    try:
+        risky()
+    except Exception as ex:
+        logging.error(ex)  # Noncompliant
+
+
+def noncompliant_str_call_in_concat():
+    try:
+        risky()
+    except Exception as ex:
+        logging.error("Error: " + str(ex))  # Noncompliant
+
+
+def noncompliant_nested_in_call():
+    try:
+        risky()
+    except Exception as ex:
+        logging.error(format_exception(ex))  # Noncompliant
+
+
+def noncompliant_except_group_with_as():
+    try:
+        risky()
+    except* ValueError as eg:
+        logging.error(f"Grouped error: {eg}")  # Noncompliant
+
+
+def noncompliant_named_logger_with_ref():
+    try:
+        risky()
+    except Exception as ex:
+        logger.error(f"Named logger: {ex}")  # Noncompliant
+
+
+def noncompliant_with_extra_kwargs():
+    try:
+        risky()
+    except Exception as ex:
+        logging.error(f"Error: {ex}", extra={"key": "val"})  # Noncompliant
+
+
+def noncompliant_in_nested_except_with_ref():
+    try:
+        risky()
+    except ValueError:
+        try:
+            other()
+        except TypeError as ex:
+            logging.error(f"Nested: {ex}")  # Noncompliant
+
+
+class MyService:
+    def noncompliant_in_method_with_ref(self):
+        try:
+            risky()
+        except Exception as ex:
+            logging.error("Error in method: %s", ex)  # Noncompliant
+
+
+# ---------- Noncompliant: traceback.format_exc() in args ----------
+
+def noncompliant_traceback_format_exc():
+    try:
+        risky()
+    except Exception:
+        logger.error(traceback.format_exc())  # Noncompliant
+
+
+def noncompliant_traceback_format_exc_in_fstring():
+    try:
+        risky()
+    except Exception:
+        logger.error(f"Error: {traceback.format_exc()}")  # Noncompliant
+
+
+def noncompliant_traceback_format_exc_positional():
+    try:
+        risky()
+    except Exception:
+        logging.error("Error: %s", traceback.format_exc())  # Noncompliant
+
+
+def noncompliant_traceback_format_exc_no_as():
+    # No `as` clause, but traceback.format_exc() is logged → still raise.
+    try:
+        risky()
+    except ValueError:
+        logging.error(traceback.format_exc())  # Noncompliant
+
+
+# ---------- Compliant: no exception involvement (FP fix anchor) ----------
+
+def compliant_no_exception_ref_with_as():
+    try:
+        risky()
+    except Exception as ex:
+        logging.error("Cleanup failed")
+
+
+def compliant_typed_except_no_as():
+    try:
+        raise ValueError("bad value")
+    except ValueError:
+        logging.error("Value error occurred")
+
+
+def compliant_bare_except():
+    try:
+        risky()
+    except:
+        logging.error("Something went wrong")
+
+
+def compliant_except_group_no_as():
+    try:
+        risky()
+    except* ValueError:
+        logging.error("Grouped error")
+
+
+def compliant_nested_except_no_as():
+    try:
+        risky()
+    except ValueError:
+        try:
+            other()
+        except TypeError:
+            logging.error("Nested error")
+
+
+def compliant_named_logger_no_ref():
+    try:
+        risky()
+    except Exception:
+        logger.error("Named logger error")
+
+
+class MyServiceCompliant:
+    def compliant_in_method_no_ref(self):
+        try:
+            risky()
+        except Exception:
+            logging.error("Error in method")
+
+
+def compliant_name_shadow(ex):
+    try:
+        risky()
+    except Exception:
+        logging.error(f"Context: {ex}")
+
+
+# ---------- Compliant: exc_info explicitly falsy or unknown ----------
+
+def compliant_with_exc_info_sys():
+    try:
+        risky()
+    except Exception:
+        logging.error("Exception occurred", exc_info=sys.exc_info())
+
+
+def compliant_with_exc_info_variable(some_var):
+    try:
+        risky()
+    except Exception:
+        logging.error("Exception occurred", exc_info=some_var)
+
+
+def compliant_with_exc_info_function_call():
+    try:
+        risky()
+    except Exception:
+        logging.error("Exception occurred", exc_info=should_log_traceback())
+
+
+def compliant_exc_info_false():
+    try:
+        risky()
+    except Exception:
+        logging.error("No traceback wanted", exc_info=False)
+
+
+def compliant_named_logger_exc_info_false():
+    try:
+        risky()
+    except Exception:
+        logger.error("No traceback wanted", exc_info=False)
+
+
+def compliant_exc_info_none():
+    try:
+        risky()
+    except Exception:
+        logging.error("No traceback wanted", exc_info=None)
+
+
+def compliant_exc_info_false_with_ref():
+    try:
+        risky()
+    except Exception as ex:
+        logging.error(f"Error: {ex}", exc_info=False)
+
+
+# ---------- Compliant: not directly inside an except clause ----------
+
+def compliant_logging_exception():
+    try:
+        risky()
+    except Exception:
+        logging.exception("Exception occurred")
+
+
+def compliant_named_logger_exception():
+    try:
+        risky()
+    except Exception:
+        logger.exception("Named logger exception")
+
+
+def compliant_error_outside_except():
+    logging.error("Not inside an except block")
+    if some_condition:
+        logging.error("Error in conditional")
+
+
+def compliant_other_log_levels_in_except():
+    try:
+        risky()
+    except Exception:
+        logging.warning("Warning")
+        logging.debug("Debug info")
+        logging.critical("Critical failure")
+        logging.info("Informational message")
+
+
+def compliant_error_in_finally():
+    try:
+        risky()
+    except Exception:
+        logging.exception("Caught exception")
+    finally:
+        logging.error("Cleanup step")
+
+
+def compliant_error_in_nested_function():
+    try:
+        risky()
+    except Exception as ex:
+        def handle():
+            logging.error(f"Inside nested function: {ex}")
+        handle()
+
+
+def compliant_error_in_lambda():
+    try:
+        risky()
+    except Exception as ex:
+        handler = lambda: logging.error(f"Inside lambda: {ex}")
+        handler()
diff --git a/python-checks/src/test/resources/checks/methodName.py b/python-checks/src/test/resources/checks/methodName.py
index 40ec5eaa97..3551cc5969 100644
--- a/python-checks/src/test/resources/checks/methodName.py
+++ b/python-checks/src/test/resources/checks/methodName.py
@@ -56,3 +56,41 @@ def y(self):  # OK
 
   def _v(self):
     ...
+
+class TestMixin:
+    @classmethod
+    def setUpTestData(cls):
+        pass
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    @classmethod
+    def setUpClass(cls):
+        pass
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+class TestMixinWithObjectBase(object):
+    def setUp(self):  # OK, whitelisted lifecycle method even in class inheriting from object
+        pass
+
+    def tearDown(self):  # OK, whitelisted lifecycle method
+        pass
+
+    @classmethod
+    def setUpClass(cls):  # OK, whitelisted lifecycle method
+        pass
+
+    @classmethod
+    def tearDownClass(cls):  # OK, whitelisted lifecycle method
+        pass
+
+    @classmethod
+    def setUpTestData(cls):  # OK, whitelisted lifecycle method
+        pass
diff --git a/python-checks/src/test/resources/checks/multipleInheritanceMROConflict.py b/python-checks/src/test/resources/checks/multipleInheritanceMROConflict.py
new file mode 100644
index 0000000000..d1c54ed55c
--- /dev/null
+++ b/python-checks/src/test/resources/checks/multipleInheritanceMROConflict.py
@@ -0,0 +1,165 @@
+class Base:
+    pass
+
+class Mid(Base):
+    pass
+
+class Leaf(Mid):
+    pass
+
+
+class Broken(Base, Leaf):  # Noncompliant {{Reorder or remove base classes to fix this MRO conflict.}}
+#     ^^^^^^ ^^^^< {{This base class is an ancestor of another listed base class appearing after it.}}
+    pass
+
+
+class CommonRoot:
+    pass
+
+class LeftChild(CommonRoot):
+    pass
+
+class RightChild(CommonRoot):
+    pass
+
+class LeftFirst(LeftChild, RightChild):
+    pass
+
+class RightFirst(RightChild, LeftChild):
+    pass
+
+class C3Conflict(LeftFirst, RightFirst):  # Noncompliant {{Reorder or remove base classes to fix this MRO conflict.}}
+    pass
+
+
+def not_a_class():
+    pass
+
+
+class CompliantPartialResolution(not_a_class, Base):
+    pass
+
+
+class OnlyMetaclass(metaclass=type):
+    pass
+
+
+class CompliantC3Order(LeftFirst, RightChild):
+    pass
+
+
+# --- Super types not fully resolved (heuristic path; full C3 is skipped) ---
+from unknown_module import ExternalMixin, ExternalOther
+
+
+# Compliant: later base not fully resolved for C3 (unknown import / incomplete hierarchy), and the
+# heuristic does not show it extending Base.
+class MidWithUnresolvedMixin(Base, ExternalMixin):
+    pass
+
+
+# Compliant: two unrelated imported bases (incomplete hierarchies); no "earlier ancestor of later" pair in the model
+class CompliantTwoUnresolvedPeers(ExternalMixin, ExternalOther):
+    pass
+
+
+# Bases not fully resolved for C3 (second base has incomplete hierarchy), yet the heuristic still
+# finds that the second base subclasses Base — flagged without running full C3.
+class ConflictMid(Base, MidWithUnresolvedMixin):  # Noncompliant {{Reorder or remove base classes to fix this MRO conflict.}}
+#     ^^^^^^^^^^^ ^^^^< {{This base class is an ancestor of another listed base class appearing after it.}}
+    pass
+
+
+# --- typeshed lies about built-in containers inheriting from collections.abc ABCs ---
+# At runtime these built-ins only inherit from `object` and are merely virtual-subclass-registered
+# against the corresponding ABCs (via abc.ABCMeta.register). Python's MRO computation succeeds, so
+# the rule must NOT flag these.
+from collections.abc import (
+    MutableMapping,
+    Mapping,
+    MutableSequence,
+    Sequence,
+    MutableSet,
+    Set as AbstractSet,
+)
+
+
+class CompliantDictMixin(MutableMapping, dict):
+    pass
+
+
+class CompliantMappingDict(Mapping, dict):
+    pass
+
+
+class CompliantListMixin(MutableSequence, list):
+    pass
+
+
+class CompliantTupleMixin(Sequence, tuple):
+    pass
+
+
+class CompliantSetMixin(MutableSet, set):
+    pass
+
+
+class CompliantFrozenSetMixin(AbstractSet, frozenset):
+    pass
+
+
+class CompliantBytearrayMixin(MutableSequence, bytearray):
+    pass
+
+
+# Smoke tests for str/bytes — typeshed lists extra ABCs (Sequence, Hashable, …) that don't appear
+# in their runtime MRO.
+class CompliantStrMixin(Sequence, str):
+    pass
+
+
+class CompliantBytesMixin(Sequence, bytes):
+    pass
+
+
+# collections.deque has the same typeshed-vs-runtime mismatch as the builtin containers:
+# typeshed declares `class deque(MutableSequence[_T])` but at runtime deque.__bases__ == (object,),
+# with MutableSequence registered as a virtual subclass via abc.ABCMeta.register().
+from collections import deque
+
+
+class CompliantDequeMixin(MutableSequence, deque):
+    pass
+
+
+# Real conflict that involves a built-in container must still be flagged: dict before its own
+# user subclass is a genuine "earlier-is-ancestor-of-later" situation that Python rejects.
+class _UserDictSubclass(dict):
+    pass
+
+
+class StillBrokenWithUserDict(dict, _UserDictSubclass):  # Noncompliant {{Reorder or remove base classes to fix this MRO conflict.}}
+#     ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^< {{This base class is an ancestor of another listed base class appearing after it.}}
+    pass
+
+
+# The reverse order is valid Python (dict comes after its subclass) and must not be flagged.
+class CompliantUserDictThenDict(_UserDictSubclass, dict):
+    pass
+
+
+# Compliant: ABC paired with a user-defined dict subclass. typeshed (falsely) lists MutableMapping
+# as ancestor of dict; the rule must not infer the same ancestry through `_UserDictSubclass`.
+# Fully-resolved bases — exercises the C3 path (wouldHaveValidMro).
+class CompliantAbcThenUserDict(MutableMapping, _UserDictSubclass):
+    pass
+
+
+# Same scenario but with an extra unresolved external mixin to force the heuristic path
+# (findAncestorConflictIndex / isOrExtendsClassAtRuntime).
+class _UserDictWithUnresolvedMixin(dict, ExternalMixin):
+    pass
+
+
+class CompliantAbcThenUserDictUnresolved(MutableMapping, _UserDictWithUnresolvedMixin):
+    pass
diff --git a/python-checks/src/test/resources/checks/mutableDefaultValueCheck.py b/python-checks/src/test/resources/checks/mutableDefaultValueCheck.py
new file mode 100644
index 0000000000..7b143cbe86
--- /dev/null
+++ b/python-checks/src/test/resources/checks/mutableDefaultValueCheck.py
@@ -0,0 +1,328 @@
+def noncompliant_examples():
+    """Examples that should trigger the rule."""
+
+    # Section: dict.fromkeys with list literal
+    def dict_fromkeys_list_literal():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, [])  # Noncompliant {{Replace this mutable value with an immutable default to avoid shared state.}}
+        #                             ^^
+
+    def dict_fromkeys_dict_literal():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, {})  # Noncompliant {{Replace this mutable value with an immutable default to avoid shared state.}}
+        #                             ^^
+
+    def dict_fromkeys_set_literal():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, {1, 2, 3})  # Noncompliant {{Replace this mutable value with an immutable default to avoid shared state.}}
+        #                             ^^^^^^^^^
+
+    def dict_fromkeys_list_constructor():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, list())  # Noncompliant {{Replace this mutable value with an immutable default to avoid shared state.}}
+        #                             ^^^^^^
+
+    def dict_fromkeys_dict_constructor():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, dict())  # Noncompliant
+        #                             ^^^^^^
+
+    def dict_fromkeys_set_constructor():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, set())  # Noncompliant
+        #                             ^^^^^
+
+    def dict_fromkeys_bytearray_constructor():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, bytearray())  # Noncompliant
+        #                             ^^^^^^^^^^^
+
+    def dict_fromkeys_list_with_elements():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, [1, 2, 3])  # Noncompliant
+        #                             ^^^^^^^^^
+
+    def dict_fromkeys_dict_with_elements():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, {'x': 1})  # Noncompliant
+        #                             ^^^^^^^^
+
+    def dict_fromkeys_from_import():
+        from builtins import dict as d
+        keys = range(5)
+        my_dict = d.fromkeys(keys, [])  # Noncompliant
+        #                          ^^
+
+    # Section: ContextVar with mutable defaults
+    def contextvar_list_literal():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', default=[])  # Noncompliant
+        #                                     ^^
+
+    def contextvar_dict_literal():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', default={})  # Noncompliant
+        #                                     ^^
+
+    def contextvar_set_literal():
+        from contextvars import ContextVar
+        my_var = ContextVar('counter', default={1, 2})  # Noncompliant
+        #                                      ^^^^^^
+
+    def contextvar_list_constructor():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', default=list())  # Noncompliant
+        #                                     ^^^^^^
+
+    def contextvar_dict_constructor():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', default=dict())  # Noncompliant
+        #                                     ^^^^^^
+
+    def contextvar_set_constructor():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', default=set())  # Noncompliant
+        #                                     ^^^^^
+
+    def contextvar_bytearray_constructor():
+        from contextvars import ContextVar
+        my_var = ContextVar('buffer', default=bytearray())  # Noncompliant
+        #                                     ^^^^^^^^^^^
+
+    def contextvar_list_with_elements():
+        from contextvars import ContextVar
+        my_var = ContextVar('items', default=[1, 2, 3])  # Noncompliant
+        #                                    ^^^^^^^^^
+
+    def contextvar_fully_qualified():
+        import contextvars
+        my_var = contextvars.ContextVar('my_var', default=[])  # Noncompliant
+        #                                                 ^^
+
+    def dict_fromkeys_bytearray_with_args():
+        keys = ['x', 'y']
+        my_dict = dict.fromkeys(keys, bytearray(b'abc'))  # Noncompliant
+        #                             ^^^^^^^^^^^^^^^^^
+
+    # Section: Variable propagation via reaching definitions analysis
+    def dict_fromkeys_variable_default():
+        keys = ['a', 'b', 'c']
+        default_value = []
+        my_dict = dict.fromkeys(keys, default_value)  # Noncompliant
+        #                             ^^^^^^^^^^^^^
+
+    def contextvar_variable_default():
+        from contextvars import ContextVar
+        initial = []
+        my_var = ContextVar('my_var', default=initial)  # Noncompliant
+        #                                     ^^^^^^^
+
+    def dict_fromkeys_variable_dict_literal():
+        keys = ['a', 'b', 'c']
+        default_value = {}
+        my_dict = dict.fromkeys(keys, default_value)  # Noncompliant
+        #                             ^^^^^^^^^^^^^
+
+    def dict_fromkeys_variable_set_literal():
+        keys = ['a', 'b', 'c']
+        default_value = {1, 2}
+        my_dict = dict.fromkeys(keys, default_value)  # Noncompliant
+        #                             ^^^^^^^^^^^^^
+
+    def dict_fromkeys_variable_list_constructor():
+        keys = ['a', 'b', 'c']
+        default_value = list()
+        my_dict = dict.fromkeys(keys, default_value)  # Noncompliant
+        #                             ^^^^^^^^^^^^^
+
+    def contextvar_variable_dict_constructor():
+        from contextvars import ContextVar
+        initial = dict()
+        my_var = ContextVar('my_var', default=initial)  # Noncompliant
+        #                                     ^^^^^^^
+
+    # Section: Conditional assignment where all branches are mutable
+    def dict_fromkeys_conditional_all_mutable():
+        keys = ['a', 'b', 'c']
+        if some_condition:
+            default_value = []
+        else:
+            default_value = {}
+        my_dict = dict.fromkeys(keys, default_value)  # Noncompliant
+        #                             ^^^^^^^^^^^^^
+
+    def contextvar_conditional_all_mutable():
+        from contextvars import ContextVar
+        if some_condition:
+            initial = set()
+        else:
+            initial = []
+        my_var = ContextVar('my_var', default=initial)  # Noncompliant
+        #                                     ^^^^^^^
+
+
+def compliant_examples():
+    """Examples that should NOT trigger the rule."""
+
+    def dict_fromkeys_no_default():
+        # No second argument — no shared mutable default
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys)
+
+    def dict_fromkeys_none_default():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, None)
+
+    def dict_fromkeys_string_default():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, "default")
+
+    def dict_fromkeys_int_default():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, 0)
+
+    def dict_fromkeys_tuple_default():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, (1, 2, 3))
+
+    def dict_fromkeys_frozenset_default():
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, frozenset({1, 2, 3}))
+
+    def dict_fromkeys_function_return_default():
+        # Cannot determine what compute_default() returns statically
+        def compute_default():
+            return []
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, compute_default())
+
+    def contextvar_no_default():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var')
+
+    def contextvar_none_default():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', default=None)
+
+    def contextvar_string_default():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', default="initial")
+
+    def contextvar_int_default():
+        from contextvars import ContextVar
+        my_var = ContextVar('counter', default=0)
+
+    def contextvar_tuple_default():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', default=(1, 2, 3))
+
+    def contextvar_frozenset_default():
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', default=frozenset({1, 2}))
+
+    def contextvar_function_return_default():
+        from contextvars import ContextVar
+        def make_default():
+            return []
+        my_var = ContextVar('my_var', default=make_default())
+
+    def dict_fromkeys_conditional_one_immutable():
+        # At least one branch assigns an immutable value — do not raise
+        keys = ['a', 'b', 'c']
+        if some_condition:
+            default_value = []
+        else:
+            default_value = None
+        my_dict = dict.fromkeys(keys, default_value)
+
+    def contextvar_conditional_one_immutable():
+        from contextvars import ContextVar
+        if some_condition:
+            initial = "safe"
+        else:
+            initial = []
+        my_var = ContextVar('my_var', default=initial)
+
+    def dict_fromkeys_variable_immutable():
+        keys = ['a', 'b', 'c']
+        default_value = 0
+        my_dict = dict.fromkeys(keys, default_value)
+
+    def contextvar_variable_immutable():
+        from contextvars import ContextVar
+        initial = "hello"
+        my_var = ContextVar('my_var', default=initial)
+
+    def dict_fromkeys_variable_from_function():
+        # Function return — reaching definitions won't resolve this
+        keys = ['a', 'b', 'c']
+        default_value = some_function()
+        my_dict = dict.fromkeys(keys, default_value)
+
+    def not_dict_fromkeys():
+        # A different class with a fromkeys method — not builtins.dict
+        class MyMapping:
+            @classmethod
+            def fromkeys(cls, keys, value=None):
+                return {}
+        my_dict = MyMapping.fromkeys(['a', 'b'], [])
+
+    def not_context_var():
+        # A class also named ContextVar but not from contextvars
+        class ContextVar:
+            def __init__(self, name, default=None):
+                pass
+        my_var = ContextVar('my_var', default=[])
+
+
+def edge_cases():
+    """Corner cases and static analysis limitations."""
+
+    def dict_fromkeys_keyword_second_arg():
+        # Second arg passed as keyword — not checked (only positional at index 1 is inspected)
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, value=[])
+
+    def dict_fromkeys_starred_args():
+        # Unpacked positional args — static analysis cannot inspect the value
+        keys = ['a', 'b', 'c']
+        args = (keys, [])
+        my_dict = dict.fromkeys(*args)
+
+    def contextvar_positional_default():
+        # Default passed positionally rather than by keyword — not flagged
+        # because the check only inspects the 'default' keyword argument
+        from contextvars import ContextVar
+        my_var = ContextVar('my_var', [])
+
+    def dict_fromkeys_chained_non_constructor_call():
+        # A call that happens to return a list but is not a recognised constructor
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, sorted([3, 1, 2]))
+
+    def contextvar_mutable_from_non_constructor():
+        # A function that returns a list but is not a recognised mutable constructor
+        from contextvars import ContextVar
+        def make_list():
+            return [1, 2, 3]
+        my_var = ContextVar('my_var', default=make_list())
+
+    def dict_fromkeys_nested_mutable_in_tuple():
+        # The default is a tuple (immutable), even though it contains a list —
+        # the outer container determines immutability for this check
+        keys = ['a', 'b', 'c']
+        my_dict = dict.fromkeys(keys, ([],))
+
+    def contextvar_inside_class():
+        from contextvars import ContextVar
+
+        class MyService:
+            state: ContextVar = ContextVar('state', default=[])  # Noncompliant
+            #                                               ^^
+            config: ContextVar = ContextVar('config', default={})  # Noncompliant
+            #                                                 ^^
+
+    def dict_fromkeys_inside_nested_function():
+        def build_mapping(key_list):
+            return dict.fromkeys(key_list, set())  # Noncompliant
+            #                              ^^^^^
diff --git a/python-checks/src/test/resources/checks/nestedLoopVariableReuse.py b/python-checks/src/test/resources/checks/nestedLoopVariableReuse.py
new file mode 100644
index 0000000000..51f366d116
--- /dev/null
+++ b/python-checks/src/test/resources/checks/nestedLoopVariableReuse.py
@@ -0,0 +1,402 @@
+def simple_shadowing():
+    for i in range(10):
+#       ^> {{Outer loop variable.}}
+        for i in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#           ^
+            pass
+
+
+def long_variable_name_shadowing():
+    for item in get_items():
+#       ^^^^> {{Outer loop variable.}}
+        for item in get_sub_items():  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "item".}}
+#           ^^^^
+            process(item)
+
+
+def shadowing_with_intervening_code():
+    for x in range(10):
+#       ^> {{Outer loop variable.}}
+        print(x)
+        if some_condition():
+            for x in range(3):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "x".}}
+#               ^
+                do_something(x)
+
+
+def tuple_unpacking_shadows_outer():
+    for i in range(10):
+#       ^> {{Outer loop variable.}}
+        for i, j in some_pairs():  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#           ^
+            pass
+
+
+def inner_shadows_outer_tuple_element():
+    for i, j in some_pairs():
+#       ^> {{Outer loop variable.}}
+        for i in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#           ^
+            pass
+
+
+def three_levels_shadowing():
+    for i in range(10):
+#       ^> {{Outer loop variable.}}
+        for i in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#           ^
+            for i in range(3):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#               ^
+                pass
+
+
+def three_levels_innermost_shadows_two_outers():
+    for i in range(10):
+        for j in range(5):
+#           ^> {{Outer loop variable.}}
+            for j in range(3):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "j".}}
+#               ^
+                pass
+
+
+def both_variables_shadow_respective_outers():
+    for i in range(10):
+        for j in range(5):
+            for i, j in some_triples():  # Noncompliant 2
+                pass
+
+
+def shadowing_inside_with_block():
+    for i in range(10):
+#       ^> {{Outer loop variable.}}
+        with open("file") as f:
+            for i in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#               ^
+                pass
+
+
+def shadowing_inside_try_block():
+    for n in range(10):
+#       ^> {{Outer loop variable.}}
+        try:
+            for n in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "n".}}
+#               ^
+                pass
+        except Exception:
+            pass
+
+
+def outer_loop_in_while_body():
+    while True:
+        for k in range(10):
+#           ^> {{Outer loop variable.}}
+            for k in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "k".}}
+#               ^
+                pass
+
+
+def underscore_plus_real_variable_shadows():
+    for k in range(10):
+#       ^> {{Outer loop variable.}}
+        for _, k in enumerate(items()):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "k".}}
+#              ^
+            pass
+
+
+def async_for_shadows_regular_for():
+    async def runner():
+        for i in range(10):
+#           ^> {{Outer loop variable.}}
+            async for i in async_iterable():  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#                     ^
+                pass
+
+
+def underscore_variable_nested():
+    for _ in range(10):
+        for _ in range(5):  # _ is a throwaway variable, not flagged
+            pass
+
+
+def underscore_prefixed_variable_nested():
+    for _item in range(10):
+        for _item in range(5):  # _item starts with _, not flagged
+            pass
+
+
+def different_variable_names():
+    for i in range(10):
+        for j in range(5):
+            pass
+
+
+def consecutive_loops_same_name():
+    for i in range(10):
+        pass
+    for i in range(5):
+        pass
+
+
+def inner_for_in_nested_function():
+    for i in range(10):
+        def helper():
+            for i in range(5):
+                pass
+        helper()
+
+
+def inner_for_in_nested_class():
+    for i in range(10):
+        class Helper:
+            def method(self):
+                for i in range(5):
+                    pass
+
+
+def inner_for_in_lambda():
+    for i in range(10):
+        transform = lambda i: i * 2
+        results = list(map(transform, range(5)))
+
+
+def inner_for_in_list_comprehension():
+    for i in range(10):
+        result = [i * 2 for i in range(5)]
+
+
+def inner_for_in_set_comprehension():
+    for i in range(10):
+        result = {i for i in range(5)}
+
+
+def inner_for_in_dict_comprehension():
+    for i in range(10):
+        result = {i: i * 2 for i in range(5)}
+
+
+def inner_for_in_generator_expr():
+    for i in range(10):
+        result = sum(i for i in range(5))
+
+
+def tuple_unpacking_no_clash():
+    for i in range(10):
+        for j, k in some_pairs():
+            pass
+
+
+def different_names_with_tuples():
+    for a, b in some_pairs():
+        for c, d in other_pairs():
+            pass
+
+
+def async_for_different_names():
+    async def runner():
+        for item in collection:
+            async for sub_item in item.children():
+                process(sub_item)
+
+
+def single_loop_only():
+    for i in range(10):
+        do_something(i)
+
+
+def deeply_nested_with_multiple_scope_boundaries():
+    for i in range(10):
+        class Outer:
+            def method(self):
+                for i in range(5):
+                    def inner():
+                        for i in range(3):
+                            pass
+
+
+
+def async_for_as_outer_shadows_inner():
+    async def runner():
+        async for i in async_iterable():
+#                 ^> {{Outer loop variable.}}
+            for i in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#               ^
+                pass
+
+
+def for_else_body_shadowing():
+    for i in range(10):
+#       ^> {{Outer loop variable.}}
+        pass
+    else:
+        for i in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#           ^
+            pass
+
+
+def for_in_finally_shadows_outer():
+    for i in range(10):
+#       ^> {{Outer loop variable.}}
+        try:
+            do_something(i)
+        finally:
+            for i in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#               ^
+                pass
+
+
+def three_levels_skip_middle():
+    for i in range(10):
+#       ^> {{Outer loop variable.}}
+        for j in range(5):
+            for i in range(3):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#               ^
+                pass
+
+
+def outer_for_inside_with():
+    with open("file") as f:
+        for i in f:
+#           ^> {{Outer loop variable.}}
+            for i in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#               ^
+                pass
+
+
+def nested_tuple_element_shadows():
+    for a, (b, c) in triples():
+#           ^> {{Outer loop variable.}}
+        for b in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "b".}}
+#           ^
+            pass
+
+
+def for_in_except_body_shadows_outer():
+    for n in range(10):
+#       ^> {{Outer loop variable.}}
+        try:
+            do_something(n)
+        except ValueError:
+            for n in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "n".}}
+#               ^
+                pass
+
+
+
+def async_for_as_outer_different_names():
+    async def runner():
+        async for item in async_iterable():
+            for sub in range(5):
+                process(item, sub)
+
+
+def for_else_body_different_names():
+    for i in range(10):
+        pass
+    else:
+        for j in range(5):
+            pass
+
+
+def for_in_finally_different_names():
+    for i in range(10):
+        try:
+            do_something(i)
+        finally:
+            for j in range(5):
+                pass
+
+
+def three_levels_no_clash():
+    for i in range(10):
+        for j in range(5):
+            for k in range(3):
+                pass
+
+
+def nested_tuple_no_clash():
+    for a, (b, c) in triples():
+        for d in range(5):
+            pass
+
+
+def consecutive_loops_at_class_body_level():
+    class MyClass:
+        for i in range(10):
+            pass
+        for i in range(5):
+            pass
+
+
+def outer_for_inside_with_different_names():
+    with open("file") as f:
+        for line in f:
+            for word in line.split():
+                process(word)
+
+
+def for_in_except_body_different_names():
+    for n in range(10):
+        try:
+            do_something(n)
+        except ValueError:
+            for m in range(5):
+                pass
+
+
+
+def starred_variable_in_outer_for_not_detected():
+    # STAR_EXPR targets are not extracted, so *b in outer loop is not tracked
+    for a, *b in some_pairs():
+        for b in range(5):
+            pass
+
+
+def starred_variable_in_inner_for_not_detected():
+    # STAR_EXPR targets are not extracted from inner loop either
+    for b in range(10):
+        for a, *b in some_pairs():
+            pass
+
+
+def three_levels_scope_boundary_between_1_and_3():
+    for i in range(10):
+        def middle():
+            for j in range(5):
+                for i in range(3):  # not flagged — funcdef is a scope boundary
+                    pass
+
+
+def deeply_nested_tuple_variable_shadows():
+    for a, (b, (c, d)) in deeply_nested():
+#               ^> {{Outer loop variable.}}
+        for c in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "c".}}
+#           ^
+            pass
+
+
+def class_body_nested_loops_same_name():
+    class MyClass:
+        for i in range(10):
+#           ^> {{Outer loop variable.}}
+            for i in range(5):  # Noncompliant {{Rename this loop variable; it shadows the outer loop variable "i".}}
+#               ^
+                pass
+
+
+def subscript_target_inner_loop_not_detected():
+    for i in range(10):
+        obj = {}
+        for obj[i] in range(5):
+            pass
+
+
+def attribute_target_inner_loop_not_detected():
+    for i in range(10):
+        class C: pass
+        c = C()
+        for c.i in range(5):
+            pass
+
+
+for _module_item in range(10):
+    pass
diff --git a/python-checks/src/test/resources/checks/noqaComment.py b/python-checks/src/test/resources/checks/noqaComment.py
index 3398d82f2b..8dad028349 100644
--- a/python-checks/src/test/resources/checks/noqaComment.py
+++ b/python-checks/src/test/resources/checks/noqaComment.py
@@ -1,5 +1,5 @@
 def divide(numerator, denominator):
-# Noncompliant@+1 {{Is #noqa used to exclude false-positive or to hide real quality flaw?}}
+# Noncompliant@+1 {{Is 'noqa' used to exclude false-positive or to hide real quality flaw?}}
     return numerator / denominator              # noqa denominator value might be 0
 #                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -30,3 +30,26 @@ def divide(numerator, denominator):
 # this is not no qa
 a = "noqa-text"
 text = "noqa is mentioned here"
+
+# --- nosec cases ---
+# S1309 is raised for both noqa and nosec suppression directives, so they share this fixture.
+
+# Noncompliant@+1 {{Is 'nosec' used to exclude false-positive or to hide real security issue?}}
+import ssl                                      # nosec
+#                                               ^^^^^^^
+
+# Noncompliant@+1
+import ssl  # nosec B101
+
+# Noncompliant@+1
+import ssl  # nosec S4423, S5332 reason text
+
+# Noncompliant@+1
+# NOSEC
+
+# a nosec just mixed in should not be detected
+
+# no sec with space should not be detected
+
+# Noncompliant@+1 {{Is 'nosec' used to exclude false-positive or to hide real security issue?}}
+# some comment followed by # nosec should be detected
diff --git a/python-checks/src/test/resources/checks/nosonarCommentFormat.py b/python-checks/src/test/resources/checks/nosonarCommentFormat.py
index aaa0e5b374..97fc0408ff 100644
--- a/python-checks/src/test/resources/checks/nosonarCommentFormat.py
+++ b/python-checks/src/test/resources/checks/nosonarCommentFormat.py
@@ -40,3 +40,18 @@
 # NOSONAR(NoSonar)
 # Noncompliant@+1
 # NOSONAR(python:S1234)
+
+# nosec
+# nosec B101
+# nosec B101, B102
+# nosec B101, B102 reason text
+# nosec: S1234, S5678
+# nosec because of foo, bar, and baz
+# Noncompliant@+1
+# nosec B101,
+# Noncompliant@+1
+# nosec ,B101
+# Noncompliant@+1
+# nosec B101,,B102
+# Noncompliant@+1
+# nosec B101 reason, B102
diff --git a/python-checks/src/test/resources/checks/pandasChainInstructionCheck.py b/python-checks/src/test/resources/checks/pandasChainInstructionCheck.py
index f72d55a2a0..4810fc1320 100644
--- a/python-checks/src/test/resources/checks/pandasChainInstructionCheck.py
+++ b/python-checks/src/test/resources/checks/pandasChainInstructionCheck.py
@@ -8,7 +8,7 @@ def non_compliant(df: pd.DataFrame, df2: DataFrame):
 #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     DataFrame().set_index("name").filter(like='joe', axis=0).groupby("team")["salary"].add(10).mean().round().to_parquet()  # Noncompliant {{Refactor this long chain of instructions with "pandas.pipe"}}
 #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-    df.set_index("name").filter(like='joe', axis=0).groupby("team")["salary"].add(10).mean().round().to_parquet()  # FN see SONARPY-1503
+    df.set_index("name").filter(like='joe', axis=0).groupby("team")["salary"].add(10).mean().round().to_parquet()  # Noncompliant {{Refactor this long chain of instructions with "pandas.pipe"}}
 
     df2.set_index("name").filter(like='joe', axis=0).groupby("team")["salary"]["test"].add(10).mean().round().to_parquet()  # Noncompliant {{Refactor this long chain of instructions with "pandas.pipe"}}
 #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -38,4 +38,3 @@ def compliant(df: pd.DataFrame, my_function, something, df2: DataFrame):
     DataFrame().set_index("name").pipe(my_function).filter(like='joe', axis=0).groupby("team")["salary"].add(10).round().mean().to_json()
 
     something.set_index("name").filter(like='joe', axis=0).groupby("team")["salary"].add(10).round().mean().to_parquet()
-
diff --git a/python-checks/src/test/resources/checks/propertyMethodWithoutReturn.py b/python-checks/src/test/resources/checks/propertyMethodWithoutReturn.py
new file mode 100644
index 0000000000..5c4e6b91ef
--- /dev/null
+++ b/python-checks/src/test/resources/checks/propertyMethodWithoutReturn.py
@@ -0,0 +1,276 @@
+import abc
+from abc import abstractmethod
+
+
+class Rectangle:
+    def __init__(self, width, height):
+        self._width = width
+        self._height = height
+        self._area = None
+
+    @property
+    def area(self):  # Noncompliant {{Add a return statement to this property method.}}
+        self._width * self._height
+
+    @property
+    def empty(self):  # Compliant - pass body is intentionally empty (stub/hook pattern)
+        pass
+
+    @property
+    def ellipsis_body(self):  # Compliant - ellipsis body is intentionally empty (stub/hook pattern)
+        ...
+
+    @property
+    def cached_area(self):  # Noncompliant {{Add a return statement to this property method.}}
+        result = self._width * self._height
+        self._area = result
+
+    @property
+    def description(self):  # Noncompliant {{Add a return statement to this property method.}}
+        if self._width > self._height:
+            value = "landscape"
+        else:
+            value = "portrait"
+
+    @property
+    def perimeter_sum(self):  # Noncompliant {{Add a return statement to this property method.}}
+        total = 0
+        for side in [self._width, self._height, self._width, self._height]:
+            total += side
+
+    @property
+    def label(self):  # Noncompliant {{Add a return statement to this property method.}}
+        print(f"Rectangle({self._width}x{self._height})")
+        self._area = self._width * self._height
+
+    @property
+    def dimensions(self):  # Noncompliant {{Add a return statement to this property method.}}
+        w = self._width
+        h = self._height
+        label = f"{w}x{h}"
+        self._area = w * h
+
+
+class Circle:
+    def __init__(self, radius):
+        self._radius = radius
+        self._cache = {}
+
+    @property
+    def radius(self):
+        return self._radius
+
+    @property
+    def diameter(self):
+        if self._radius > 0:
+            return self._radius * 2
+        return 0
+
+    @property
+    def area(self):
+        raise NotImplementedError("Subclass must implement area")
+
+    @property
+    def none_value(self):
+        return None
+
+    @property
+    def cached_value(self):
+        try:
+            return self._cache["value"]
+        except KeyError:
+            return self._radius * 2
+
+    @property
+    def early_return(self):
+        if self._radius <= 0:
+            return 0
+        return self._radius * 3.14159
+
+    def compute_area(self):
+        self._radius * self._radius * 3.14159
+
+
+class AbstractShape(abc.ABC):
+    @property
+    @abstractmethod
+    def area(self):
+        pass
+
+    @property
+    @abc.abstractmethod
+    def perimeter(self):
+        pass
+
+    @property
+    @abstractmethod
+    def volume(self):  # Compliant - @abstractmethod with non-empty body
+        self._volume = 0
+
+    @property
+    @abc.abstractmethod
+    def surface(self):  # Compliant - @abc.abstractmethod with non-empty body
+        self._surface = 0
+
+
+class DataStream:
+    def __init__(self, data):
+        self._data = data
+
+    @property
+    def values(self):
+        yield from self._data
+
+    @property
+    def pairs(self):
+        for i, v in enumerate(self._data):
+            yield i, v
+
+
+class NestedFunctionInProperty:
+    def __init__(self, value):
+        self._value = value
+
+    @property
+    def computed(self):  # Noncompliant {{Add a return statement to this property method.}}
+        def helper():
+            return self._value * 2
+
+    @property
+    def with_nested_and_return(self):
+        def helper():
+            return self._value * 2
+        return helper()
+
+
+class PropertyWithSetterDeleter:
+    def __init__(self):
+        self._x = 0
+
+    @property
+    def x(self):
+        return self._x
+
+    @x.setter
+    def x(self, value):  # Compliant - setter does not need a return statement
+        self._x = value
+
+    @x.deleter
+    def x(self):  # Compliant - deleter does not need a return statement
+        del self._x
+
+
+class BareReturnCases:
+    def __init__(self):
+        self._value = 0
+
+    @property
+    def only_bare_return(self):
+        return  # Compliant - has a return statement (returns None implicitly)
+
+    @property
+    def bare_return_in_branch(self):
+        if self._value < 0:
+            return  # Compliant - has a return statement
+        self._value = 0
+
+
+class TryCasesWithoutReturn:
+    def __init__(self):
+        self._data = {}
+
+    @property
+    def no_return_in_try(self):  # Noncompliant {{Add a return statement to this property method.}}
+        try:
+            self._data["key"]  # result not returned, no raise in except
+        except KeyError:
+            print("missing")
+
+    @property
+    def raise_only_in_except(self):  # Compliant - raises in except branch
+        try:
+            return self._data["key"]
+        except KeyError:
+            raise ValueError("key not found")
+
+    @property
+    def via_finally(self):  # Compliant - return in finally block
+        try:
+            pass
+        finally:
+            return self._data.get("key")
+
+
+import functools
+
+
+class FunctoolsCachedProperty:
+    def __init__(self, radius):
+        self._radius = radius
+
+    @functools.cached_property
+    def area(self):  # Compliant - @functools.cached_property is out of scope for this rule
+        self._radius * self._radius * 3.14159
+
+
+# ---- Protocol exemptions ----
+from typing import Protocol
+
+
+class ReadBuffer(Protocol):
+    @property
+    def mode(self) -> str:
+        ...  # Compliant - Protocol stub with ellipsis body
+
+    @property
+    def closed(self) -> bool:
+        pass  # Compliant - Protocol stub with pass body
+
+    @property
+    def name(self) -> str:
+        """The name of the buffer."""
+        ...  # Compliant - Protocol stub with docstring + ellipsis
+
+
+class ReadBufferWithMissingReturn(Protocol):
+    @property
+    def mode(self) -> str:  # Noncompliant {{Add a return statement to this property method.}}
+        self._mode = "r"
+
+
+# ---- ABC subclass exemptions (no @abstractmethod, body is pass/...) ----
+class AbstractBase(abc.ABC):
+    @property
+    def value(self):
+        ...  # Compliant - ABC subclass with ellipsis body, conventionally abstract
+
+    @property
+    def label(self):
+        pass  # Compliant - ABC subclass with pass body, conventionally abstract
+
+    @property
+    def description(self):
+        """Returns a description."""
+        ...  # Compliant - ABC subclass with docstring + ellipsis
+
+    @property
+    def computed(self):  # Noncompliant {{Add a return statement to this property method.}}
+        result = self._x * 2
+
+
+class PlainClassWithEmptyBody:
+    """A plain class (not ABC, not Protocol) - empty body is still compliant."""
+    def __init__(self):
+        self._value = 0
+
+    @property
+    def stub(self):
+        pass  # Compliant - pass body is always exempt regardless of class type
+
+    @property
+    def stub_ellipsis(self):
+        ...  # Compliant - ellipsis body is always exempt regardless of class type
+
+    @property
+    def real_body(self):  # Noncompliant {{Add a return statement to this property method.}}
+        self._value * 2
diff --git a/python-checks/src/test/resources/checks/propertyMethodWithoutReturnShadowingProperty.py b/python-checks/src/test/resources/checks/propertyMethodWithoutReturnShadowingProperty.py
new file mode 100644
index 0000000000..6059fe962b
--- /dev/null
+++ b/python-checks/src/test/resources/checks/propertyMethodWithoutReturnShadowingProperty.py
@@ -0,0 +1,14 @@
+
+def property(func):
+    """A user-defined decorator that happens to be named 'property'."""
+    return func
+
+
+class UserDefinedPropertyDecorator:
+    def __init__(self):
+        self._value = 0
+
+    @property
+    def value(self):  # Compliant - built-in 'property' is shadowed by the user-defined decorator above; type matcher correctly excludes this
+        self._value * 2
+
diff --git a/python-checks/src/test/resources/checks/pydanticConfigDictValidationOptions.py b/python-checks/src/test/resources/checks/pydanticConfigDictValidationOptions.py
new file mode 100644
index 0000000000..ed970e7310
--- /dev/null
+++ b/python-checks/src/test/resources/checks/pydanticConfigDictValidationOptions.py
@@ -0,0 +1,157 @@
+from pydantic import BaseModel, ConfigDict, Field
+
+
+# =====================
+# NON-COMPLIANT CASES
+# =====================
+
+class ModelBothFalse(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=False,  # < 1 {{Also set to "False" here.}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^^>
+        validate_by_name=False  # Noncompliant {{Enable at least one of "validate_by_alias" or "validate_by_name".}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+class ModelBothFalseOrderReversed(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=False,  # Noncompliant {{Enable at least one of "validate_by_alias" or "validate_by_name".}}
+        validate_by_alias=False  # < 1 {{Also set to "False" here.}}
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+class ModelBothFalseOtherArgs(BaseModel):
+    model_config = ConfigDict(
+        frozen=True,
+        validate_by_alias=False,  # < 1 {{Also set to "False" here.}}
+        validate_by_name=False  # Noncompliant {{Enable at least one of "validate_by_alias" or "validate_by_name".}}
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+# Variable holding False
+flag_false = False
+
+class ModelBothVarFalse(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=flag_false,  # < 1 {{Also set to "False" here.}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^>
+        validate_by_name=flag_false  # Noncompliant {{Enable at least one of "validate_by_alias" or "validate_by_name".}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+class ModelAliasFalseLiteralNameVarFalse(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=False,  # < 1 {{Also set to "False" here.}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^^>
+        validate_by_name=flag_false  # Noncompliant {{Enable at least one of "validate_by_alias" or "validate_by_name".}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+class ModelAliasVarFalseNameFalseLiteral(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=flag_false,  # < 1 {{Also set to "False" here.}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^>
+        validate_by_name=False  # Noncompliant {{Enable at least one of "validate_by_alias" or "validate_by_name".}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+# =====================
+# COMPLIANT CASES
+# =====================
+
+class ModelAliasTrue(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=True,
+        validate_by_name=False
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+class ModelNameTrue(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=False,
+        validate_by_name=True
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+class ModelBothTrue(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=True,
+        validate_by_name=True
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+class ModelOnlyAlias(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=False
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+class ModelOnlyName(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=False
+    )
+    my_field: str
+
+
+class ModelEmpty(BaseModel):
+    model_config = ConfigDict()
+    my_field: str
+
+
+class ModelNoValidation(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    my_field: str
+
+
+class ModelAliasFalseNameMissing(BaseModel):
+    model_config = ConfigDict(validate_by_alias=False)
+    my_field: str
+
+
+flag_true = True
+
+class ModelAliasVarTrueNameFalse(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=flag_true,
+        validate_by_name=False
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+class ModelBothVarTrue(BaseModel):
+    model_config = ConfigDict(
+        validate_by_alias=flag_true,
+        validate_by_name=flag_true
+    )
+    my_field: str = Field(alias='my_alias')
+
+
+# ConfigDict is always from pydantic, so this is still flagged even in non-BaseModel classes
+class NotPydanticSubclass:
+    model_config = ConfigDict(
+        validate_by_alias=False,  # < 1 {{Also set to "False" here.}}
+        validate_by_name=False  # Noncompliant {{Enable at least one of "validate_by_alias" or "validate_by_name".}}
+    )
+
+
+from some_other_lib import ConfigDict as OtherConfigDict
+
+class NotFlaggedNonPydanticConfigDict:
+    model_config = OtherConfigDict(
+        validate_by_alias=False,
+        validate_by_name=False
+    )
diff --git a/python-checks/src/test/resources/checks/pydanticCoreSerializationFallback.py b/python-checks/src/test/resources/checks/pydanticCoreSerializationFallback.py
new file mode 100644
index 0000000000..ead00d45f6
--- /dev/null
+++ b/python-checks/src/test/resources/checks/pydanticCoreSerializationFallback.py
@@ -0,0 +1,81 @@
+import pydantic_core
+from pydantic_core import to_json, to_jsonable_python
+
+
+class CustomObject:
+    def __init__(self, value):
+        self.value = value
+
+
+def handle_unknown(obj):
+    return str(obj)
+
+class CustomObject2(Unknown):
+    def __init__(self, value):
+        self.value = value
+
+
+data = {"key": CustomObject(42)}
+
+# =====================
+# NON-COMPLIANT CASES
+# =====================
+
+result = to_json(data)  # Noncompliant {{Add a "fallback" parameter to this pydantic-core serialization call.}}
+result = to_jsonable_python(data)  # Noncompliant
+
+result = to_json(data, indent=2)  # Noncompliant
+result = to_jsonable_python(data, exclude=None)  # Noncompliant
+
+result = pydantic_core.to_json(data)  # Noncompliant
+result = pydantic_core.to_jsonable_python(data)  # Noncompliant
+
+result = pydantic_core.to_json(CustomObject(42))  # Noncompliant
+
+# =====================
+# COMPLIANT CASES
+# =====================
+
+result = to_json(data, fallback=handle_unknown)
+result = to_jsonable_python(data, fallback=handle_unknown)
+
+result = to_json(data, indent=2, fallback=handle_unknown)
+result = to_jsonable_python(data, exclude=None, fallback=str)
+
+result = pydantic_core.to_json(data, fallback=handle_unknown)
+result = pydantic_core.to_jsonable_python(data, fallback=handle_unknown)
+
+result = pydantic_core.to_jsonable_python(CustomObject2(42))  
+
+result = pydantic_core.to_json()
+def foo(**kwargs):
+    result = pydantic_core.to_json(**kwargs) # Coverage
+
+# =====================
+# UNRELATED CALLS - should not trigger
+# =====================
+
+import other_lib
+result = other_lib.to_json(data)
+
+# =====================
+# PYDANTIC BASEMODEL EXCEPTION - should not trigger
+# =====================
+
+from pydantic import BaseModel
+
+class MyModel(BaseModel):
+    value: int
+
+class MySubModel(MyModel):
+    name: str
+
+model = MyModel(value=42)
+sub_model = MySubModel(value=1, name="test")
+
+result = to_json(model)  # Compliant: pydantic.BaseModel instance
+result = to_jsonable_python(model)  # Compliant: pydantic.BaseModel instance
+result = to_json(sub_model)  # Compliant: subclass of pydantic.BaseModel
+result = to_jsonable_python(sub_model)  # Compliant: subclass of pydantic.BaseModel
+result = pydantic_core.to_json(model)  # Compliant: pydantic.BaseModel instance
+result = pydantic_core.to_jsonable_python(model)  # Compliant: pydantic.BaseModel instance
diff --git a/python-checks/src/test/resources/checks/pydanticDataclassRevalidation.py b/python-checks/src/test/resources/checks/pydanticDataclassRevalidation.py
new file mode 100644
index 0000000000..717f52d10a
--- /dev/null
+++ b/python-checks/src/test/resources/checks/pydanticDataclassRevalidation.py
@@ -0,0 +1,330 @@
+import dataclasses
+import pydantic.dataclasses as pydantic_dataclasses
+from pydantic import BaseModel, ConfigDict
+from typing import Optional, List, Annotated, Union
+
+
+# =====================
+# NON-COMPLIANT CASES
+# =====================
+
+@dataclasses.dataclass
+class User:
+    name: str
+
+
+class Foo(BaseModel):  # Noncompliant {{Explicitly set 'revalidate_instances' in this Pydantic model's configuration.}}
+#     ^^^
+    user: User
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+
+@dataclasses.dataclass
+class Address:
+    street: str
+
+
+class Bar(BaseModel):  # Noncompliant
+#     ^^^
+    address: Address
+#   ^^^^^^^< {{The dataclass-typed field is defined here.}}
+
+
+# model_config present but without revalidate_instances
+class Baz(BaseModel):  # Noncompliant
+#     ^^^
+    model_config = ConfigDict(frozen=True)
+    user: User
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+
+# multiple dataclass fields - one issue per class, secondary on each field
+class MultiField(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^
+    user: User
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+    address: Address
+#   ^^^^^^^< {{The dataclass-typed field is defined here.}}
+
+
+# =====================
+# FINDING 2: WRAPPED ANNOTATION TYPES (NON-COMPLIANT)
+# =====================
+
+class WrappedOptional(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^^^^^
+    user: Optional[User]
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+class WrappedList(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^
+    users: List[User]
+#   ^^^^^< {{The dataclass-typed field is defined here.}}
+
+class WrappedAnnotated(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^^^^^^
+    user: Annotated[User, 'meta']
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+class WrappedUnion(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^^
+    user: Union[User, None]
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+class WrappedNestedGeneric(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^^^^^^^^^^
+    data: dict[str, User]
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+
+# =====================
+# PYDANTIC DATACLASS AS FIELD TYPE
+# =====================
+
+@pydantic_dataclasses.dataclass
+class PydanticUser:
+    name: str
+
+
+class WithPydanticDataclass(BaseModel):  # already validated
+    user: PydanticUser
+
+
+# =====================
+# COMPLIANT CASES
+# =====================
+
+# revalidate_instances='always' via ConfigDict
+class Compliant(BaseModel):
+    model_config = ConfigDict(revalidate_instances='always')
+    user: User
+
+
+# ConfigDict assigned to a non-standard variable name — still detected by callee type
+class CompliantNonStandardVarName(BaseModel):
+    my_config = ConfigDict(revalidate_instances='always')
+    user: User
+
+
+# revalidate_instances='always' with other options
+class CompliantWithOtherOptions(BaseModel):
+    model_config = ConfigDict(frozen=True, revalidate_instances='always')
+    user: User
+
+
+# revalidate_instances='never' — any explicit value is acceptable
+class CompliantNever(BaseModel):
+    model_config = ConfigDict(revalidate_instances='never')
+    user: User
+
+
+# revalidate_instances='subclass-instances' — any explicit value is acceptable
+class CompliantSubclassInstances(BaseModel):
+    model_config = ConfigDict(revalidate_instances='subclass-instances')
+    user: User
+
+
+# class keyword argument syntax — 'always'
+class CompliantKwargAlways(BaseModel, revalidate_instances='always'):
+    user: User
+
+
+# class keyword argument syntax — 'never' (explicit opt-out)
+class CompliantKwargNever(BaseModel, revalidate_instances='never'):
+    user: User
+
+
+# class keyword argument syntax — 'subclass-instances'
+class CompliantKwargSubclass(BaseModel, revalidate_instances='subclass-instances'):
+    user: User
+
+
+# No dataclass-typed fields — no issue
+class NoDataclassField(BaseModel):
+    name: str
+    age: int
+
+
+# Field typed as a plain class (not a dataclass) — no issue
+class PlainClass:
+    name: str
+
+class WithPlainClass(BaseModel):
+    obj: PlainClass
+
+
+# Not a BaseModel subclass — no issue
+@dataclasses.dataclass
+class StandaloneDataclass:
+    value: int
+
+
+# Not a BaseModel — dataclass with dataclass field
+@dataclasses.dataclass
+class Container:
+    user: User
+
+
+# =====================
+# FINDING 1: DICT-LITERAL model_config (COMPLIANT)
+# =====================
+
+# dict-literal with revalidate_instances — any explicit value is acceptable
+class CompliantDictLiteralAlways(BaseModel):
+    model_config = {'revalidate_instances': 'always'}
+    user: User
+
+class CompliantDictLiteralNever(BaseModel):
+    model_config = {'revalidate_instances': 'never'}
+    user: User
+
+class CompliantDictLiteralWithOtherKeys(BaseModel):
+    model_config = {'frozen': True, 'revalidate_instances': 'always'}
+    user: User
+
+
+# =====================
+# FINDING 2: WRAPPED ANNOTATION TYPES (COMPLIANT)
+# =====================
+
+class CompliantWrappedOptional(BaseModel):
+    model_config = ConfigDict(revalidate_instances='always')
+    user: Optional[User]
+
+class CompliantWrappedList(BaseModel):
+    model_config = ConfigDict(revalidate_instances='always')
+    users: List[User]
+
+
+# =====================
+# FINDING 3: INHERITED revalidate_instances (COMPLIANT)
+# =====================
+
+class BaseWithConfigDictReval(BaseModel):
+    model_config = ConfigDict(revalidate_instances='always')
+
+class ChildOfConfigDictBase(BaseWithConfigDictReval):  # Compliant — inherits via ConfigDict
+    user: User
+
+class BaseWithKwargReval(BaseModel, revalidate_instances='always'):
+    pass
+
+class ChildOfKwargBase(BaseWithKwargReval):  # Compliant — inherits via keyword arg
+    user: User
+
+# Multi-hop: grandchild inherits from a child that inherits revalidate_instances
+class GrandchildOfConfigDictBase(ChildOfConfigDictBase):  # Compliant — inherits transitively
+    address: Address
+
+
+# =====================
+# FINDING 4: MODULE-LEVEL / ALIASED ConfigDict VARIABLE (COMPLIANT)
+# =====================
+
+# module-level variable holding ConfigDict with revalidate_instances
+COMMON_CONFIG = ConfigDict(revalidate_instances='always')
+
+class CompliantModuleLevelConfigVar(BaseModel):
+    model_config = COMMON_CONFIG
+    user: User
+
+
+# chained alias: A = ConfigDict(...); B = A; model_config = B
+ALIAS_A = ConfigDict(revalidate_instances='always')
+ALIAS_B = ALIAS_A
+
+class CompliantChainedAlias(BaseModel):
+    model_config = ALIAS_B
+    user: User
+
+
+# module-level dict literal with revalidate_instances
+DICT_CONFIG = {'revalidate_instances': 'always'}
+
+class CompliantModuleLevelDictVar(BaseModel):
+    model_config = DICT_CONFIG
+    user: User
+
+
+# module-level variable WITHOUT revalidate_instances — still noncompliant
+BAD_CONFIG = ConfigDict(frozen=True)
+
+class NoncompliantModuleLevelConfigVar(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    model_config = BAD_CONFIG
+    user: User
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+
+# =====================
+# EDGE CASES
+# =====================
+
+# Class with no fields — no issue
+class EmptyModel(BaseModel):
+    pass
+
+
+# BaseModel with only class variables — no issue (no AnnotatedAssignment without annotation being a dataclass)
+class ModelWithClassVar(BaseModel):
+    name: str
+
+
+# Cross-file dataclass fields cannot be detected — treated as unknown type, no issue raised
+# (no test case needed here since we only detect same-file dataclasses)
+
+# Unresolved type annotation — no issue (unknown type, conservative)
+class ModelWithUnresolved(BaseModel):
+    user: UnknownType
+
+
+# =====================
+# COVERAGE: ADDITIONAL EDGE CASES
+# =====================
+
+# PEP-604 union syntax (X | Y) — noncompliant
+class PEP604Union(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^
+    user: User | None
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+
+# PEP-604 union syntax — compliant with revalidate_instances set
+class CompliantPEP604Union(BaseModel):
+    model_config = ConfigDict(revalidate_instances='always')
+    user: User | None
+
+
+# PEP-604 union where right operand is the dataclass — noncompliant
+class PEP604UnionRightOperand(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+    user: None | User
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+
+# model_config assigned something that is not a ConfigDict call, dict literal, or variable reference —
+# no revalidate_instances found, so issue IS raised
+def make_config():
+    return ConfigDict(revalidate_instances='always')
+
+class ModelWithCallRHS(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^^^^^^
+    model_config = make_config()
+    user: User
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+
+# Ambiguous Name RHS (assigned in multiple places) — conservative, treated as no config
+AMBIGUOUS_CONFIG = ConfigDict(revalidate_instances='always')
+AMBIGUOUS_CONFIG = ConfigDict(frozen=True)
+
+class ModelWithAmbiguousConfig(BaseModel):  # Noncompliant
+#     ^^^^^^^^^^^^^^^^^^^^^^^^
+    model_config = AMBIGUOUS_CONFIG
+    user: User
+#   ^^^^< {{The dataclass-typed field is defined here.}}
+
+
+# Annotation that is not a Name, SubscriptionExpression, or BinaryExpression — no issue
+class ModelWithLiteralAnnotation(BaseModel):
+    value: 42
diff --git a/python-checks/src/test/resources/checks/pydanticDoubleUnderscorePrivateAttribute.py b/python-checks/src/test/resources/checks/pydanticDoubleUnderscorePrivateAttribute.py
new file mode 100644
index 0000000000..ad69e4e5d6
--- /dev/null
+++ b/python-checks/src/test/resources/checks/pydanticDoubleUnderscorePrivateAttribute.py
@@ -0,0 +1,78 @@
+from pydantic import BaseModel, PrivateAttr
+
+# =====================
+# NON-COMPLIANT CASES
+# =====================
+
+class Model(BaseModel):
+    __counter: int = PrivateAttr(default=0)  # Noncompliant {{Replace this double underscore prefix with a single underscore to avoid Python name mangling.}}
+#   ^^^^^^^^^
+
+class ModelWithMultipleIssues(BaseModel):
+    __name: str = PrivateAttr(default="")  # Noncompliant
+    __value: int = PrivateAttr(default=0)  # Noncompliant
+    _ok: str = PrivateAttr(default="ok")  # Compliant
+
+class ModelWithDunderAndRegular(BaseModel):
+    __private: str = PrivateAttr(default="")  # Noncompliant
+    name: str  # Compliant: not private at all
+    _single: int = PrivateAttr(default=1)  # Compliant
+
+class SubModel(BaseModel):
+    __sub_attr: float = PrivateAttr(default=0.0)  # Noncompliant
+
+# =====================
+# COMPLIANT CASES
+# =====================
+
+class CompliantModel(BaseModel):
+    _counter: int = PrivateAttr(default=0)  # Compliant: single underscore prefix
+    name: str  # Compliant: regular field, no underscore
+    _private: str = PrivateAttr(default="hello")  # Compliant
+
+class ModelWithDunderMethod(BaseModel):
+    name: str  # Compliant
+    # Dunder methods should not be flagged (they're not private attributes with double underscore prefix)
+
+class RegularClass:
+    __attr: int = 0  # Compliant: not a Pydantic model
+
+class ModelWithoutDoubleUnderscore(BaseModel):
+    _attr: str = PrivateAttr(default="")  # Compliant: single underscore
+
+# Inheritance from non-Pydantic class should not be flagged
+class NonPydanticBase:
+    pass
+
+class DerivedFromNonPydantic(NonPydanticBase):
+    __attr: int = 0  # Compliant: not a Pydantic model
+
+# =====================
+# EDGE CASES
+# =====================
+
+class EmptyModel(BaseModel):
+    pass  # Compliant: no fields
+
+class ModelWithRegularFields(BaseModel):
+    id: int  # Compliant: no underscore
+    name: str  # Compliant: no underscore
+    _status: str = PrivateAttr(default="active")  # Compliant: single underscore
+
+# Unannotated assignments with PrivateAttr should be flagged
+class ModelWithUnannotatedPrivateAttr(BaseModel):
+    __counter = PrivateAttr(default=0)  # Noncompliant {{Replace this double underscore prefix with a single underscore to avoid Python name mangling.}}
+#   ^^^^^^^^^
+
+class ModelWithMultipleUnannotatedIssues(BaseModel):
+    __id = PrivateAttr(default=0)  # Noncompliant
+    __label = PrivateAttr(default="")  # Noncompliant
+    _ok = PrivateAttr(default=0)  # Compliant: single underscore
+
+# Unannotated plain class variable (not a PrivateAttr call) should not be flagged
+class ModelWithUnannotatedPlainVar(BaseModel):
+    __plain = 0  # Compliant: not a PrivateAttr call
+
+# Non-pydantic class with unannotated double-underscore PrivateAttr should not be flagged
+class RegularClassWithUnannotatedPrivateAttr:
+    __counter = PrivateAttr(default=0)  # Compliant: not a Pydantic model
diff --git a/python-checks/src/test/resources/checks/pydanticFieldValidatorReturn.py b/python-checks/src/test/resources/checks/pydanticFieldValidatorReturn.py
new file mode 100644
index 0000000000..a821964332
--- /dev/null
+++ b/python-checks/src/test/resources/checks/pydanticFieldValidatorReturn.py
@@ -0,0 +1,254 @@
+from pydantic import BaseModel, field_validator
+from pydantic.functional_validators import field_validator as fv_direct
+
+
+class UserModel(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def clean_name(cls, v):  # Noncompliant {{Add a return statement to this Pydantic field validator.}}
+    #   ^^^^^^^^^^
+        v = v.lower().strip()
+
+
+class UserModel2(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):  # Noncompliant {{Add a return statement to this Pydantic field validator.}}
+        if len(v) < 2:
+            raise ValueError("Name too short")
+        # Missing return v on the valid path
+
+
+class EmptyReturn(BaseModel):
+    a: str
+    b: str
+
+    @field_validator("a", "b")
+    @classmethod
+    def validate_fields(cls, v):  # Noncompliant {{Add a return statement to this Pydantic field validator.}}
+        return
+
+
+class MultiFieldModel(BaseModel):
+    a: str
+    b: str
+
+    @field_validator("a", "b")
+    @classmethod
+    def validate_fields(cls, v):  # Noncompliant {{Add a return statement to this Pydantic field validator.}}
+        v = v.strip()
+
+
+class AliasedImportNoncompliant(BaseModel):
+    name: str
+
+    @fv_direct("name")
+    @classmethod
+    def transform_name(cls, v):  # Noncompliant {{Add a return statement to this Pydantic field validator.}}
+        v = v.upper()
+
+# for loop: no return at all — must still be flagged
+class NoncompliantForLoopNoReturn(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):  # Noncompliant {{Add a return statement to this Pydantic field validator.}}
+        for char in v:
+            print(char)
+
+# for loop: no return at all — must still be flagged
+class NoncompliantWhileLoopNoReturn(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):  # Noncompliant {{Add a return statement to this Pydantic field validator.}}
+        while v:
+            print(char)
+
+class CompliantModel(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def clean_name(cls, v):
+        return v.lower().strip()
+
+
+class CompliantConditional(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        if len(v) < 2:
+            raise ValueError("Name too short")
+        return v
+
+
+class CompliantConditionalBothBranches(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        if v.startswith("Dr."):
+            return v
+        else:
+            return v.title()
+
+
+class CompliantAlwaysRaises(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        raise NotImplementedError("Not supported")
+
+
+class CompliantAliasImport(BaseModel):
+    name: str
+
+    @fv_direct("name")
+    @classmethod
+    def clean_name(cls, v):
+        return v.lower()
+
+
+class CompliantPassBody(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        pass
+
+
+class CompliantEllipsisBody(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        ...
+
+
+
+
+# Non-BaseModel class should not be flagged even with pydantic decorator
+class PlainClass:
+    name: str
+
+    @fv_direct("name")
+    @classmethod
+    def clean_name(cls, v):
+        v = v.lower()
+
+
+class CompliantYield(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        yield v
+
+
+# with-statement: the WITH_STMT is an end-predecessor in CFG — must not produce a false positive
+class CompliantWithStatement(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        with open("/dev/null") as f:
+            return f.read() or v
+
+
+# while loop with return inside: the WHILE_STMT is an end-predecessor in CFG — must not produce a false positive
+class CompliantWhileLoop(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        while something:
+            return v.strip()
+
+class CompliantIfTrue(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        if True:
+            return v.strip()
+
+
+# try/except: CFG falls back to simple check; no return AND raises → not flagged (always raises on both paths)
+class CompliantTryExceptAlwaysRaises(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        try:
+            int(v)
+        except ValueError:
+            raise ValueError("Not a number")
+        raise ValueError("Should not be a number")
+
+
+# try/except: CFG falls back; has an explicit return → not flagged
+class CompliantTryExceptWithReturn(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        try:
+            return v.strip()
+        except Exception:
+            raise ValueError("Unexpected error")
+
+
+
+def not_in_model():
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        v.strip() 
+        
+# A locally-defined field_validator function (not pydantic) should not be flagged
+def my_field_validator(*fields, **kwargs):
+    pass
+
+class NotPydanticFieldValidator(BaseModel):
+    name: str
+
+    @my_field_validator("name")
+    @classmethod
+    def clean_name(cls, v):
+        v = v.lower()
+
+
+# for loop: return inside loop — must not produce a false positive
+class CompliantForLoopReturn(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v):
+        for char in v:
+            return char
+
+
+
diff --git a/python-checks/src/test/resources/checks/pydanticJsonSchemaInputTypeWithAfterMode.py b/python-checks/src/test/resources/checks/pydanticJsonSchemaInputTypeWithAfterMode.py
new file mode 100644
index 0000000000..4f70b4bc1b
--- /dev/null
+++ b/python-checks/src/test/resources/checks/pydanticJsonSchemaInputTypeWithAfterMode.py
@@ -0,0 +1,159 @@
+from pydantic import BaseModel, field_validator
+
+# =====================
+# NON-COMPLIANT CASES
+# =====================
+
+class ModelAfterMode(BaseModel):
+    a: str
+
+    @field_validator('a', mode='after', json_schema_input_type=str)  # Noncompliant {{Remove "json_schema_input_type" or change the validator mode to "before", "plain", or "wrap".}}
+    #                                   ^^^^^^^^^^^^^^^^^^^^^^
+    #                          ^^^^^^^@-1< {{mode is set here.}}
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
+
+class ModelDefaultMode(BaseModel):
+    a: str
+
+    @field_validator('a', json_schema_input_type=str)  # Noncompliant {{Remove "json_schema_input_type" or change the validator mode to "before", "plain", or "wrap".}}
+    @classmethod
+    def validate_a_default(cls, v):
+        return v
+
+
+class ModelAfterModeMultipleFields(BaseModel):
+    a: str
+    b: int
+
+    @field_validator('a', 'b', mode='after', json_schema_input_type=str)  # Noncompliant {{Remove "json_schema_input_type" or change the validator mode to "before", "plain", or "wrap".}}
+    @classmethod
+    def validate_ab(cls, v):
+        return v
+
+
+class ModelModeAfterExplicit(BaseModel):
+    a: str
+
+    @field_validator('a', json_schema_input_type=int, mode='after')  # Noncompliant {{Remove "json_schema_input_type" or change the validator mode to "before", "plain", or "wrap".}}
+    @classmethod
+    def validate_a2(cls, v):
+        return v
+
+# =====================
+# COMPLIANT CASES
+# =====================
+
+class ModelBeforeMode(BaseModel):
+    a: str
+
+    @field_validator('a', mode='before', json_schema_input_type=str)
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
+
+class ModelPlainMode(BaseModel):
+    a: str
+
+    @field_validator('a', mode='plain', json_schema_input_type=str)
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
+
+class ModelWrapMode(BaseModel):
+    a: str
+
+    @field_validator('a', mode='wrap', json_schema_input_type=str)
+    @classmethod
+    def validate_a(cls, v, handler):
+        return handler(v)
+
+
+class ModelAfterModeNoJsonSchemaInputType(BaseModel):
+    a: str
+
+    @field_validator('a', mode='after')
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
+
+class ModelNoJsonSchemaInputType(BaseModel):
+    a: str
+
+    @field_validator('a')
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
+
+class ModelModeIsVariable(BaseModel):
+    a: str
+
+    VALIDATOR_MODE = 'after'
+
+    @field_validator('a', mode=VALIDATOR_MODE, json_schema_input_type=str)
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
+
+# A function with the same name but no pydantic import should not be flagged
+def field_validator(*fields, **kwargs):
+    pass
+
+@field_validator('a', mode='after', json_schema_input_type=str)
+def validate_local(cls, v):
+    return v
+
+
+# =====================
+# DIRECT MODULE IMPORT
+# =====================
+
+from pydantic.functional_validators import field_validator as fv_direct  # noqa: E402
+
+class ModelDirectImportNoncompliant(BaseModel):
+    a: str
+
+    @fv_direct('a', mode='after', json_schema_input_type=str)  # Noncompliant {{Remove "json_schema_input_type" or change the validator mode to "before", "plain", or "wrap".}}
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
+
+class ModelDirectImportCompliant(BaseModel):
+    a: str
+
+    @fv_direct('a', mode='before', json_schema_input_type=str)
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
+
+# =====================
+# ALIASED IMPORT
+# =====================
+
+from pydantic import field_validator as fv_alias  # noqa: E402
+
+class ModelAliasedImportNoncompliant(BaseModel):
+    a: str
+
+    @fv_alias('a', json_schema_input_type=str)  # Noncompliant {{Remove "json_schema_input_type" or change the validator mode to "before", "plain", or "wrap".}}
+    @classmethod
+    def validate_a(cls, v):
+        return v
+
+
+class ModelAliasedImportCompliant(BaseModel):
+    a: str
+
+    @fv_alias('a', mode='before', json_schema_input_type=str)
+    @classmethod
+    def validate_a(cls, v):
+        return v
diff --git a/python-checks/src/test/resources/checks/pydanticMultipleInheritanceConfigCheck.py b/python-checks/src/test/resources/checks/pydanticMultipleInheritanceConfigCheck.py
new file mode 100644
index 0000000000..a9463437d8
--- /dev/null
+++ b/python-checks/src/test/resources/checks/pydanticMultipleInheritanceConfigCheck.py
@@ -0,0 +1,243 @@
+from pydantic import BaseModel, ConfigDict
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+# =====================
+# NON-COMPLIANT CASES
+# =====================
+
+class Base1(BaseModel):
+    model_config = ConfigDict(str_to_lower=True)
+
+class Base2(BaseModel):
+    model_config = ConfigDict(str_to_upper=True)
+
+class Model(Base1, Base2):  # Noncompliant {{Refactor this Pydantic model to avoid multiple inheritance with conflicting configurations.}}
+#     ^^^^^
+    x: str
+
+
+class Base3(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+class Base4(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+class ModelThreeBases(Base1, Base3, Base4):  # Noncompliant
+#     ^^^^^^^^^^^^^^^
+    y: int
+
+
+# Multiple noncompliant models in the same file
+class AnotherModel(Base1, Base2):  # Noncompliant
+#     ^^^^^^^^^^^^
+    z: str
+
+
+# =====================
+# COMPLIANT CASES
+# =====================
+
+# Only one base has model_config
+class Base5(BaseModel):
+    pass
+
+class ModelOneConfigBase(Base1, Base5):  # Compliant - only Base1 has model_config
+    a: str
+
+
+# Neither base defines model_config
+class BaseNoConfig1(BaseModel):
+    x: int
+
+class BaseNoConfig2(BaseModel):
+    y: str
+
+class ModelNoConfig(BaseNoConfig1, BaseNoConfig2):  # Compliant
+    z: float
+
+
+# Single inheritance with config
+class ModelSingleInheritance(Base1):  # Compliant
+    b: int
+
+
+# Single base with config, no multiple inheritance conflict
+class ModelWithOwnConfig(Base1):  # Compliant
+    model_config = ConfigDict(str_to_lower=True)
+    c: str
+
+
+# Not a Pydantic BaseModel subclass
+class NotPydantic:
+    model_config = ConfigDict(str_to_lower=True)
+
+class AlsoNotPydantic:
+    model_config = ConfigDict(str_to_upper=True)
+
+class NotPydanticMultiple(NotPydantic, AlsoNotPydantic):  # Compliant - not a Pydantic model
+    pass
+
+
+# BaseModel itself is not flagged
+class DirectBaseModel(BaseModel):
+    pass
+
+
+# Only the current class itself defines model_config (not multiple bases)
+class ModelConfigOnChild(Base1):  # Compliant - only one base (Base1) has model_config
+    model_config = ConfigDict(frozen=True)
+    d: int
+
+
+# =====================
+# INDIRECT INHERITANCE (MRO-based detection)
+# =====================
+
+# Base that inherits model_config from Base1 without redefining it
+class IntermediateBase(Base1):
+    pass
+
+# Both IntermediateBase (via Base1) and Base2 define model_config — conflict
+class ModelIndirect(IntermediateBase, Base2):  # Noncompliant {{Refactor this Pydantic model to avoid multiple inheritance with conflicting configurations.}}
+#     ^^^^^^^^^^^^^
+    e: str
+
+# Two levels of indirection
+class DeepBase(IntermediateBase):
+    pass
+
+class ModelDeep(DeepBase, Base2):  # Noncompliant
+#     ^^^^^^^^^
+    f: str
+
+# Both direct bases ultimately source model_config from the same class (Base1) — no conflict
+class ModelSameSource(IntermediateBase, Base1):  # Compliant - same model_config source
+    g: str
+
+# Intermediate base that does NOT carry a config, paired with a base that does — only one definer
+class IntermediateNoConfig(Base5):
+    pass
+
+class ModelOneIndirectConfig(IntermediateNoConfig, Base1):  # Compliant - only Base1 defines model_config
+    h: str
+
+
+# =====================
+# EDGE CASES
+# =====================
+
+# Keyword argument in the base list must be ignored (not treated as a positional base)
+class ModelWithKeywordArg(Base1, Base2, metaclass=type):  # Noncompliant
+#     ^^^^^^^^^^^^^^^^^^^
+    i: str
+
+# Diamond inheritance: A and B both inherit from Base1 (which defines model_config).
+# The BFS visited-guard must deduplicate Base1 so it is only counted once — no conflict.
+class DiamondA(Base1):
+    pass
+
+class DiamondB(Base1):
+    pass
+
+class ModelDiamond(DiamondA, DiamondB):  # Compliant - single model_config source (Base1)
+    j: str
+
+# A base expression that does not resolve to a ClassType (e.g. a call) must be skipped
+def make_base():
+    return Base1
+
+class ModelWithCallBase(make_base(), Base2):  # Compliant - make_base() is not a ClassType
+    k: str
+
+
+# =====================
+# EXCEPTION: child defines own model_config
+# =====================
+
+# Child defines its own model_config with multiple conflicting bases — compliant (exception)
+class ModelOwnConfigMultiBases(Base1, Base2):  # Compliant - child defines its own model_config
+    model_config = ConfigDict(frozen=True)
+    x: str
+
+# Same exception with three bases
+class ModelOwnConfigThreeBases(Base1, Base2, Base3):  # Compliant - child defines its own model_config
+    model_config = ConfigDict(frozen=True)
+    y: int
+
+# Exception holds even with indirect/MRO-based conflict
+class ModelOwnConfigIndirect(IntermediateBase, Base2):  # Compliant - child defines its own model_config
+    model_config = ConfigDict(str_to_lower=True)
+    z: str
+
+
+# =====================
+# UNRESOLVED SUPERCLASSES
+# =====================
+
+# One superclass cannot be resolved to a ClassType (unknown import) — the rule skips it.
+# Only Base1 contributes a model_config definer, so no conflict is raised.
+class ModelOneUnresolved(UnknownBase, Base1):  # Compliant - UnknownBase is unresolved
+    m: str
+
+# Both superclasses are unresolved — no ClassType definer is found at all, no issue raised.
+class ModelBothUnresolved(UnknownBase1, UnknownBase2):  # Compliant - both are unresolved
+    n: str
+
+
+# =====================
+# KNOWN FALSE POSITIVE
+# =====================
+
+# Two bases define identical model_config values — no actual conflict exists, but the rule
+# flags it anyway because it does not compare ConfigDict values, only structural presence.
+# Pydantic's merge behavior is still non-MRO regardless of whether values currently agree,
+# and they can diverge independently in future code changes.
+class BaseIdentical1(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+class BaseIdentical2(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+# Known false positive: configs are identical but the rule flags it anyway because it does
+# not compare ConfigDict values — only their structural presence.
+class ModelIdenticalConfig(BaseIdentical1, BaseIdentical2):  # Noncompliant
+#     ^^^^^^^^^^^^^^^^^^^^
+    l: str
+
+
+# =====================
+# SINGLE BRANCH FP REGRESSION
+# =====================
+
+# PatchTaskInstanceBody defines model_config locally; PlainBaseModel does not.
+# The only model_config "branch" is PatchTaskInstanceBody (BaseModel is shared root).
+# No conflict → must not raise.
+class PatchTaskInstanceBody(BaseModel):
+    model_config = ConfigDict(str_to_lower=True)
+    task_id: str
+
+class PlainBaseModel(BaseModel):
+    pass
+
+class BulkTaskInstanceBody(PatchTaskInstanceBody, PlainBaseModel):  # Compliant - only one branch defines model_config
+    dag_id: str
+
+
+# =====================
+# GENERIC BASE CLASS (FP regression)
+# =====================
+
+class StrictBaseModel(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+# Compliant - only one Pydantic base with model_config; Generic[T] is not a Pydantic config source
+class BulkBaseAction(StrictBaseModel, Generic[T]):  # Compliant
+    pass
+
+# Two distinct Pydantic bases each with their own model_config — still noncompliant even with Generic[T] mixed in
+class ConflictingGenericModel(Base1, Base2, Generic[T]):  # Noncompliant
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+    pass
diff --git a/python-checks/src/test/resources/checks/pydanticOptionalFieldDefault.py b/python-checks/src/test/resources/checks/pydanticOptionalFieldDefault.py
index 37fb8af289..49088f2256 100644
--- a/python-checks/src/test/resources/checks/pydanticOptionalFieldDefault.py
+++ b/python-checks/src/test/resources/checks/pydanticOptionalFieldDefault.py
@@ -10,24 +10,16 @@ class UserModel(BaseModel):
     email: Optional[str]  # Noncompliant {{Add an explicit default value to this optional field.}}
 #          ^^^^^^^^^^^^^
 
-class ProfileModel(BaseModel):
-    bio: str | None  # Noncompliant
-#        ^^^^^^^^^^
-
 class SettingsModel(BaseModel):
     theme: Optional[str] = Field(...)  # Noncompliant
 #          ^^^^^^^^^^^^^
 
-class ArticleModel(BaseModel):
-    title: str
-    subtitle: Optional[str]  # Noncompliant
-    tags: list[str] | None  # Noncompliant
-
-class DataModel(BaseModel):
-    value: Union[str, None]  # Noncompliant
+class ModelWithMethods(BaseModel):
+    optional_field: Optional[str]  # Noncompliant
+    required_field: str
 
-class ComplexModel(BaseModel):
-    data: Union[str, int, None]  # Noncompliant
+    def some_method(self):
+        pass
 
 # =====================
 # COMPLIANT CASES
@@ -35,90 +27,88 @@ class ComplexModel(BaseModel):
 
 class UserModelCompliant(BaseModel):
     name: str
-    email: Optional[str] = None  # Compliant
+    email: Optional[str] = None
 
 class ProfileModelCompliant(BaseModel):
-    bio: str | None = None  # Compliant
+    bio: str | None = None
 
 class SettingsModelCompliant(BaseModel):
-    theme: Optional[str] = Field(default=None)  # Compliant
-    priority: Optional[int] = Field(default=0)  # Compliant
+    theme: Optional[str] = Field(default=None)
+    priority: Optional[int] = Field(default=0)
 
 class RequiredModel(BaseModel):
-    required_field: str  # Compliant - not Optional
-    another_field: int = Field(...)  # Compliant - not Optional
+    required_field: str
+    another_field: int = Field(...)
 
 class ConfigModel(BaseModel):
-    timeout: Optional[int] = 30  # Compliant - has default
+    timeout: Optional[int] = 30
 
 class FactoryModel(BaseModel):
-    items: Optional[list] = Field(default_factory=list)  # Compliant
+    items: Optional[list] = Field(default_factory=list)
 
 class RegularClass:
-    value: Optional[str]  # Compliant - not a BaseModel
+    value: Optional[str]
+
+class BitwiseOrNoneCompliant(BaseModel):
+    reason: int | None
+
+class BitwiseOrNoneWithFieldEllipsisCompliant(BaseModel):
+    bio: str | None = Field(...)
+
+class BitwiseOrNoneWithFieldDefaultCompliant(BaseModel):
+    title: str | None = Field(default=None)
+
+class NoneLeftCompliant(BaseModel):
+    description: None | str
+
+class NoneLeftWithFieldEllipsisCompliant(BaseModel):
+    value: None | str = Field(...)
+
+class UnionWithNoneCompliant(BaseModel):
+    data: Union[str, None]
+
+class UnionWithFieldEllipsisCompliant(BaseModel):
+    value: Union[str, None] = Field(...)
 
 # =====================
 # EDGE CASES
 # =====================
 
 class ComplexModelCompliant(BaseModel):
-    data: Union[str, int, None] = None  # Compliant
+    data: Union[str, int, None] = None
 
 class EmptyModel(BaseModel):
-    pass  # Compliant - no fields
+    pass
 
 class OnlyRequiredModel(BaseModel):
     id: int
-    name: str 
-
-# =====================
-# ADDITIONAL EDGE CASES FOR COVERAGE
-# =====================
-
-class NoneLeftModel(BaseModel):
-    value: None | str  # Noncompliant
-
-class NestedUnionLeftModel(BaseModel):
-    value: None | str | int  # Noncompliant
+    name: str
 
 class EmptyFieldModel(BaseModel):
-    value: Optional[str] = Field()  # Compliant - Field() with no ellipsis
+    value: Optional[str] = Field()
 
 class FieldWithValueModel(BaseModel):
-    value: Optional[str] = Field(42)  # Compliant - first arg is not ellipsis
+    value: Optional[str] = Field(42)
 
 class FieldWithKeywordFirstModel(BaseModel):
-    value: Optional[str] = Field(default=None)  # Compliant - default is specified
+    value: Optional[str] = Field(default=None)
 
 class FieldEllipsisWithDefaultModel(BaseModel):
-    value: Optional[str] = Field(..., default=None)  # Compliant
+    value: Optional[str] = Field(..., default=None)
 
 class FieldEllipsisWithFactoryModel(BaseModel):
-    value: Optional[list] = Field(..., default_factory=list)  # Compliant
-
-class ModelWithMethods(BaseModel):
-    optional_field: Optional[str]  # Noncompliant
-    required_field: str
-
-    def some_method(self):
-        pass
-
-    @classmethod
-    def class_method(cls):
-        pass
+    value: Optional[list] = Field(..., default_factory=list)
 
-class MultiNestedModel(BaseModel):
-    left_none: None | str  # Noncompliant
-    right_none: str | None  # Noncompliant
-    deep_left: None | int | str  # Noncompliant
-    deep_right1: int | str | None  # Noncompliant
-    deep_right2: int | str | str | str  # Compliant
+class MultiNoneFieldCompliant(BaseModel):
+    deep_left: None | int | str
+    deep_right: int | str | None
+    no_none: int | str | str
 
 def custom_field():
     return None
 
 class CustomFieldModel(BaseModel):
-    value: Optional[str] = custom_field()  # Compliant - not pydantic.Field
+    value: Optional[str] = custom_field()
 
 class OtherSubscriptionModel(BaseModel):
-    value: list[str]  # Compliant
+    value: list[str]
diff --git a/python-checks/src/test/resources/checks/pydanticSkipValidationWithConstraints.py b/python-checks/src/test/resources/checks/pydanticSkipValidationWithConstraints.py
new file mode 100644
index 0000000000..2f2937d8c0
--- /dev/null
+++ b/python-checks/src/test/resources/checks/pydanticSkipValidationWithConstraints.py
@@ -0,0 +1,135 @@
+from typing import Annotated
+from pydantic import BaseModel, SkipValidation, Field
+from pydantic import StringConstraints, AfterValidator, BeforeValidator, PlainValidator, WrapValidator
+
+# =====================
+# NON-COMPLIANT CASES
+# =====================
+
+class Model(BaseModel):
+    # SkipValidation combined with Field in the same Annotated
+    value: Annotated[int, SkipValidation, Field(gt=0)]  # Noncompliant {{Remove either "SkipValidation" or the validation constraints from this annotation.}}
+    #                     ^^^^^^^^^^^^^^ 1^^^^^^^^^^^< {{Validation constraint is set here.}}
+
+    constraint = Field(gt=0)
+    #            ^^^^^^^^^^^> {{Validation constraint is set here.}}
+    value: Annotated[int, SkipValidation, constraint]  # Noncompliant {{Remove either "SkipValidation" or the validation constraints from this annotation.}}
+    #                     ^^^^^^^^^^^^^^ 
+    # Field constraint in inner Annotated, SkipValidation in outer
+    other: Annotated[Annotated[int, Field(gt=0)], SkipValidation]  # Noncompliant
+    #                               ^^^^^^^^^^^> {{Validation constraint is set here.}}
+    #                                             ^^^^^^^^^^^^^^@-1 1
+
+    # SkipValidation with StringConstraints
+    name: Annotated[str, SkipValidation, StringConstraints(min_length=1)]  # Noncompliant
+    #                    ^^^^^^^^^^^^^^ 1^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Validation constraint is set here.}}
+
+    # SkipValidation combined with AfterValidator
+    validated: Annotated[int, SkipValidation, AfterValidator(lambda x: x)]  # Noncompliant
+    #                         ^^^^^^^^^^^^^^ 1^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Validation constraint is set here.}}
+
+    # SkipValidation combined with BeforeValidator (constraint before SkipValidation)
+    pre_validated: Annotated[int, BeforeValidator(lambda x: x), SkipValidation]  # Noncompliant
+    #                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^> {{Validation constraint is set here.}}
+    #                                                           ^^^^^^^^^^^^^^@-1 1
+
+    # SkipValidation in outer, StringConstraints in nested inner Annotated
+    nested_str: Annotated[Annotated[str, StringConstraints(min_length=1)], SkipValidation]  # Noncompliant
+    #                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^> {{Validation constraint is set here.}}
+    #                                                                      ^^^^^^^^^^^^^^@-1 1
+
+    # SkipValidation combined with PlainValidator
+    plain: Annotated[int, SkipValidation, PlainValidator(lambda x: x)]  # Noncompliant
+    #                     ^^^^^^^^^^^^^^ 1^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Validation constraint is set here.}}
+
+    # SkipValidation combined with WrapValidator
+    wrapped: Annotated[int, SkipValidation, WrapValidator(lambda x, handler: handler(x))]  # Noncompliant
+    #                       ^^^^^^^^^^^^^^ 1^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Validation constraint is set here.}}
+
+    # Field with min_length kwarg + SkipValidation
+    min_len_field: Annotated[str, SkipValidation, Field(min_length=1)]  # Noncompliant
+    #                             ^^^^^^^^^^^^^^ 1^^^^^^^^^^^^^^^^^^^< {{Validation constraint is set here.}}
+
+    # Field with multiple constraint kwargs + SkipValidation
+    multi_constraint: Annotated[int, SkipValidation, Field(ge=0, le=100)]  # Noncompliant
+    #                                ^^^^^^^^^^^^^^ 1^^^^^^^^^^^^^^^^^^^< {{Validation constraint is set here.}}
+
+    # Field with constraint kwarg mixed with metadata kwargs + SkipValidation: still a constraint
+    mixed_field: Annotated[int, SkipValidation, Field(default=0, gt=0)]  # Noncompliant
+    #                           ^^^^^^^^^^^^^^ 1^^^^^^^^^^^^^^^^^^^^^^< {{Validation constraint is set here.}}
+
+
+# =====================
+# COMPLIANT CASES
+# =====================
+
+class CompliantModel(BaseModel):
+    # SkipValidation alone with a subscript type - OK
+    trusted: SkipValidation[int]
+
+    # SkipValidation as only annotation in Annotated - OK
+    also_trusted: Annotated[int, SkipValidation]
+
+    # Field alone without SkipValidation - OK
+    constrained: Annotated[int, Field(gt=0)]
+
+    # StringConstraints alone - OK
+    string_field: Annotated[str, StringConstraints(min_length=1)]
+
+    # Nested Annotated without SkipValidation - OK
+    nested: Annotated[Annotated[int, Field(gt=0)], Field(lt=100)]
+
+    # AfterValidator alone - OK
+    after: Annotated[int, AfterValidator(lambda x: x)]
+
+    # Plain type annotation - OK
+    plain_type: int
+
+    # Field with a default - OK
+    optional: Annotated[int, Field(default=0)]
+
+    # Field with only default + SkipValidation: no validation constraint, so OK
+    default_trusted: Annotated[int, SkipValidation, Field(default=0)]
+
+    # Field with only alias + SkipValidation: alias is metadata, not a constraint
+    alias_trusted: Annotated[str, SkipValidation, Field(alias="x")]
+
+    # Field with only description + SkipValidation: description is metadata, not a constraint
+    desc_trusted: Annotated[str, SkipValidation, Field(description="some description")]
+
+    # Field with only serialization_alias + SkipValidation
+    ser_alias_trusted: Annotated[str, SkipValidation, Field(serialization_alias="x")]
+
+    # Field with only validation_alias + SkipValidation
+    val_alias_trusted: Annotated[str, SkipValidation, Field(validation_alias="x")]
+
+    # Field with default_factory + SkipValidation: no constraint, OK
+    factory_trusted: Annotated[list, SkipValidation, Field(default_factory=list)]
+
+    # Field with title + SkipValidation: metadata only
+    title_trusted: Annotated[str, SkipValidation, Field(title="My Field")]
+
+    # Field with exclude + SkipValidation: serialization flag, not a constraint
+    exclude_trusted: Annotated[str, SkipValidation, Field(exclude=True)]
+
+    # Behavioral flags: with SkipValidation, no validation runs so these have no effect regardless of value
+    strict_true: Annotated[int, SkipValidation, Field(strict=True)]
+    strict_false: Annotated[int, SkipValidation, Field(strict=False)]
+    allow_inf_nan_true: Annotated[float, SkipValidation, Field(allow_inf_nan=True)]
+    allow_inf_nan_false: Annotated[float, SkipValidation, Field(allow_inf_nan=False)]
+    coerce_str: Annotated[str, SkipValidation, Field(coerce_numbers_to_str=True)]
+    fail_fast_field: Annotated[int, SkipValidation, Field(fail_fast=True)]
+    discriminator_field: Annotated[int, SkipValidation, Field(discriminator="type")]
+
+
+# Regular class (not a Pydantic model) - should not trigger
+class RegularClass:
+    value: Annotated[int, SkipValidation, Field(gt=0)]
+
+
+# Standalone annotations outside any class - should not trigger
+standalone: Annotated[int, SkipValidation, Field(gt=0)]
+
+
+def process(value: Annotated[int, SkipValidation, Field(gt=0)]) -> None:
+    pass
diff --git a/python-checks/src/test/resources/checks/pytestPluginsNonTestModule.py b/python-checks/src/test/resources/checks/pytestPluginsNonTestModule.py
new file mode 100644
index 0000000000..c96144203e
--- /dev/null
+++ b/python-checks/src/test/resources/checks/pytestPluginsNonTestModule.py
@@ -0,0 +1,2 @@
+def helper():
+    return 42
diff --git a/python-checks/src/test/resources/checks/pythonJoseVerification.py b/python-checks/src/test/resources/checks/pythonJoseVerification.py
index 682daa6344..fc4827115a 100644
--- a/python-checks/src/test/resources/checks/pythonJoseVerification.py
+++ b/python-checks/src/test/resources/checks/pythonJoseVerification.py
@@ -217,6 +217,25 @@ async def compliant_verify(token: str | None = None):
         ...
 
 
+@router.get('/compliant_peek_then_verify_jws')
+async def compliant_peek_then_verify_jws(token: str | None = None, key=None):
+    unverified = jws.verify(token, None, None, verify=False)  # Compliant: same token is re-verified below
+    return jws.verify(token, key, ["HS256"], verify=True)
+
+
+@router.get('/compliant_peek_then_verify_decode_dict')
+async def compliant_peek_then_verify_decode_dict(token: str | None = None, key=None):
+    unverified = jwt.decode(token, None, options={"verify_signature": False})  # Compliant: same token is re-decoded below with a real key
+    return jwt.decode(token, key, algorithms=["HS256"])
+
+
+# only other_token is re-verified below, not token
+@router.get('/noncompliant_peek_then_verify_different_token')
+async def noncompliant_peek_then_verify_different_token(token: str | None = None, other_token: str | None = None, key=None):
+    unverified = jwt.decode(token, None, options={"verify_signature": False})  # Noncompliant
+    return jwt.decode(other_token, key, algorithms=["HS256"])
+
+
 x = []
 class TestInfiniteRecursion():
     x = x
diff --git a/python-checks/src/test/resources/checks/redundantJump.py b/python-checks/src/test/resources/checks/redundantJump.py
index dbfecbf3be..f25ca6dcd2 100644
--- a/python-checks/src/test/resources/checks/redundantJump.py
+++ b/python-checks/src/test/resources/checks/redundantJump.py
@@ -340,3 +340,47 @@ def match_statement_single_return(value):
     match value:
       case "42":
         return  # OK
+
+
+import marimo
+
+app = marimo.App()
+
+
+@app.cell
+def _(mo, engine):
+    _df = mo.sql(f"""SELECT * FROM table""", engine=engine)
+    return  # OK
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md("# Dashboard")
+    return  # OK
+
+
+@app.cell
+def _(mo, condition):
+    if condition:
+        mo.md("Condition met")
+        return  # OK
+    mo.md("Condition not met")
+    return  # OK
+
+
+@app.function
+def helper():
+    x = 1
+    return  # OK
+
+
+@app.function
+def helper_with_condition(condition):
+    if condition:
+        return  # OK
+    return  # OK
+
+
+def not_a_marimo_cell():
+    x = 1
+    return  # Noncompliant
diff --git a/python-checks/src/test/resources/checks/regex/invalidRegexCheck.py b/python-checks/src/test/resources/checks/regex/invalidRegexCheck.py
index 0812baa5fd..11ef566ed7 100644
--- a/python-checks/src/test/resources/checks/regex/invalidRegexCheck.py
+++ b/python-checks/src/test/resources/checks/regex/invalidRegexCheck.py
@@ -29,4 +29,4 @@ def false_positives():
             (?P.*?)
           \]
         ''', re.X | re.S)
-    # Noncompliant@-5
+    # Fixed in analyzer-commons 2.28
diff --git a/python-checks/src/test/resources/checks/regex/redosCheck.py b/python-checks/src/test/resources/checks/regex/redosCheck.py
index 7c9a10be6d..3234eabd5b 100644
--- a/python-checks/src/test/resources/checks/regex/redosCheck.py
+++ b/python-checks/src/test/resources/checks/regex/redosCheck.py
@@ -36,11 +36,11 @@ def full_and_partial_match(_input):
     re.split(r"(.*,)*", _input)  # OK, partial match
     re.sub(r"(.*,)*", _input)  # OK, partial match
     re.subn(r"(.*,)*", _input)  # OK, partial match
-    re.search(r"\s*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.findall(r"\s*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.split(r"\s*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.sub(r"\s*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.subn(r"\s*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.search(r"\s*\s*+,", _input)  # OK, polynomial cases now reported by S8786
+    re.findall(r"\s*\s*+,", _input)  # OK
+    re.split(r"\s*\s*+,", _input)  # OK
+    re.sub(r"\s*\s*+,", _input)  # OK
+    re.subn(r"\s*\s*+,", _input)  # OK
 
 def always_exponential(_input):
     re.fullmatch(r"(.*,)*?", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to exponential runtime due to backtracking, cannot lead to denial of service.}}
@@ -55,12 +55,12 @@ def always_exponential(_input):
 
 
 def always_quadratic(_input):
-    re.fullmatch(r"x*\w*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.fullmatch(r".*.*X", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.match(r".*.*X", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.fullmatch(r"x*a*x*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.fullmatch(r"x*(xy?)*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.fullmatch(r"x*xx*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.fullmatch(r"x*\w*", _input)  # OK, polynomial cases now reported by S8786
+    re.fullmatch(r".*.*X", _input)  # OK
+    re.match(r".*.*X", _input)  # OK
+    re.fullmatch(r"x*a*x*", _input)  # OK
+    re.fullmatch(r"x*(xy?)*", _input)  # OK
+    re.fullmatch(r"x*xx*", _input)  # OK
 
 
 def always_quadratic_other_match_types(_input):
@@ -71,59 +71,59 @@ def always_quadratic_other_match_types(_input):
     re.match(r"x*(xy?)*", _input)  # OK
     re.search(r"x*(xy?)*", _input)  # OK
     re.match(r"x*xx*", _input)  # OK
-    # FP
-    re.search(r"x*xx*", _input)  # Noncompliant
+    re.search(r"x*xx*", _input)  # OK
 
 
 def non_possessive_followed_by_possessive(_input):
-    re.fullmatch(r".*\s*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.fullmatch(r".*\s*", _input)  # OK, polynomial cases now reported by S8786
     re.match(r".*\s*", _input)  # OK
     re.search(r".*\s*", _input)  # OK
-    re.fullmatch(r".*\s*+", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.fullmatch(r".*\s*+", _input)  # OK
     re.match(r".*\s*+", _input)  # OK
     re.search(r".*\s*+", _input)  # OK
-    re.fullmatch(r"\s*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.match(r"\s*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.search(r"\s*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.fullmatch(r"[a\s]*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.match(r"[a\s]*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.search(r"[a\s]*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.fullmatch(r"[a\s]*b*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.match(r"[a\s]*b*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.search(r"[a\s]*b*\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.fullmatch(r"\s*\s*+,", _input)  # OK
+    re.match(r"\s*\s*+,", _input)  # OK
+    re.search(r"\s*\s*+,", _input)  # OK
+    re.fullmatch(r"[a\s]*\s*+,", _input)  # OK
+    re.match(r"[a\s]*\s*+,", _input)  # OK
+    re.search(r"[a\s]*\s*+,", _input)  # OK
+    re.fullmatch(r"[a\s]*b*\s*+,", _input)  # OK
+    re.match(r"[a\s]*b*\s*+,", _input)  # OK
+    re.search(r"[a\s]*b*\s*+,", _input)  # OK
 
 
 def implicit_reluctant_quantifier_in_partial_match(_input):
-    re.search(r"\s*,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.search(r"\s*,", _input)  # OK, polynomial cases now reported by S8786
     re.match(r"\s*,", _input)  # OK
     re.fullmatch(r"\s*,", _input)  # OK
-    re.search(r"\s*+,", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.search(r"\s*+,", _input)  # OK
     re.match(r"\s*+,", _input)  # OK
     re.fullmatch(r"\s*+,", _input)  # OK
-    re.search(r"(?s:.*)\s*,(?s:.*)", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.match(r"(?s:.*)\s*,(?s:.*)", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.fullmatch(r"(?s:.*)\s*,(?s:.*)", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.search(r"(?s:.*)\s*+,(?s:.*)", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.match(r"(?s:.*)\s*+,(?s:.*)", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.fullmatch(r"(?s:.*)\s*+,(?s:.*)", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.search(r"(?s:.*)\s*,(?s:.*)", _input)  # OK
+    re.match(r"(?s:.*)\s*,(?s:.*)", _input)  # OK
+    re.fullmatch(r"(?s:.*)\s*,(?s:.*)", _input)  # OK
+    re.search(r"(?s:.*)\s*+,(?s:.*)", _input)  # OK
+    re.match(r"(?s:.*)\s*+,(?s:.*)", _input)  # OK
+    re.fullmatch(r"(?s:.*)\s*+,(?s:.*)", _input)  # OK
 
 
 def different_polynomials(_input):
-    re.fullmatch(r"x*x*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.fullmatch(r"x*x*", _input)  # OK, polynomial cases now reported by S8786
     re.match(r"x*x*", _input)  # OK
     re.search(r"x*x*", _input)  # OK
-    re.fullmatch(r"x*x*x*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.fullmatch(r"x*x*x*", _input)  # OK
     re.match(r"x*x*x*", _input)  # OK
     re.search(r"x*x*x*", _input)  # OK
-    re.fullmatch(r"x*x*x*x*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.fullmatch(r"x*x*x*x*", _input)  # OK
     re.match(r"x*x*x*x*", _input)  # OK
     re.search(r"x*x*x*x*", _input)  # OK
-    re.fullmatch(r"x*x*x*x*x*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.fullmatch(r"x*x*x*x*x*", _input)  # OK
     re.match(r"x*x*x*x*x*", _input)  # OK
     re.search(r"x*x*x*x*x*", _input)  # OK
-    re.fullmatch(r"[^=]*.*.*=.*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.match(r"[^=]*.*.*=.*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
-    re.search(r"[^=]*.*.*=.*", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.fullmatch(r"[^=]*.*.*=.*", _input)  # OK
+    re.match(r"[^=]*.*.*=.*", _input)  # OK
+    re.search(r"[^=]*.*.*=.*", _input)  # OK
+    re.search(r"a+b", _input) # OK
 
 
 def should_be_ok(_input):
@@ -138,10 +138,10 @@ def should_be_ok(_input):
 def java9_optimized_cases_not_optimized_in_python(_input):
     re.fullmatch(r"(.?,)*X", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to exponential runtime due to backtracking, cannot lead to denial of service.}}
     re.match(r"(.?,)*X", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to exponential runtime due to backtracking, cannot lead to denial of service.}}
-    re.search(r"(.?,)*X", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.search(r"(.?,)*X", _input)  # OK, ALWAYS_QUADRATIC in search mode, reported by S8786
     re.fullmatch(r"(.?,)*\1", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to exponential runtime due to backtracking, cannot lead to denial of service.}}
     re.match(r"(.?,)*\1", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to exponential runtime due to backtracking, cannot lead to denial of service.}}
-    re.search(r"(.?,)*\1", _input)  # Noncompliant  {{Make sure the regex used here, which is vulnerable to polynomial runtime due to backtracking, cannot lead to denial of service.}}
+    re.search(r"(.?,)*\1", _input)  # OK, ALWAYS_QUADRATIC in search mode, reported by S8786
     re.fullmatch(r"(?:(.?)\1,)*", _input)  # FN
     re.match(r"(?:(.?)\1,)*", _input)  # OK
     re.search(r"(?:(.?)\1,)*", _input)  # OK
@@ -198,6 +198,6 @@ def compliant(_input):
     re.fullmatch(r"(?s)(.*,)*.*", _input)
     re.fullmatch(r"(?:(.)\1)*", _input)
     re.fullmatch(r"(?:\1|x(.))*", _input)
-    re.fullmatch(r"(?:\1|x(.))+", _input)
+    re.fullmatch(r"(?:\1|x(.))+" , _input)
     re.fullmatch(r"(?:\1|x(.)){1,2}", _input)
     re.fullmatch(r"(.)(?:\1\2|x(.))*", _input)
diff --git a/python-checks/src/test/resources/checks/regex/superLinearRegexCheck.py b/python-checks/src/test/resources/checks/regex/superLinearRegexCheck.py
new file mode 100644
index 0000000000..f65ca587de
--- /dev/null
+++ b/python-checks/src/test/resources/checks/regex/superLinearRegexCheck.py
@@ -0,0 +1,114 @@
+import re
+
+
+def re_compile(_input):
+    p1 = re.compile(r"\s*\s*+,")  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    p2 = re.compile(r"\s*\s*+,")  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    p3 = re.compile(r"\s*\s*+,")  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    p1.fullmatch(_input)
+    p2.match(_input)
+    p3.search(_input)
+
+
+def full_and_partial_match(_input):
+    re.search(r"\s*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.findall(r"\s*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.split(r"\s*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.sub(r"\s*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.subn(r"\s*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+
+
+def always_quadratic(_input):
+    re.fullmatch(r"x*\w*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.fullmatch(r".*.*X", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r".*.*X", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.fullmatch(r"x*a*x*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.fullmatch(r"x*(xy?)*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.fullmatch(r"x*xx*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+
+
+def always_quadratic_other_match_types(_input):
+    re.match(r"x*\w*", _input)  # OK
+    re.search(r"x*\w*", _input)  # OK
+    re.match(r"x*a*x*", _input)  # OK
+    re.search(r"x*a*x*", _input)  # OK
+    re.match(r"x*(xy?)*", _input)  # OK
+    re.search(r"x*(xy?)*", _input)  # OK
+    re.match(r"x*xx*", _input)  # OK
+    # FP
+    re.search(r"x*xx*", _input)  # Noncompliant
+
+
+def non_possessive_followed_by_possessive(_input):
+    re.fullmatch(r".*\s*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r".*\s*", _input)  # OK
+    re.search(r".*\s*", _input)  # OK
+    re.fullmatch(r".*\s*+", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r".*\s*+", _input)  # OK
+    re.search(r".*\s*+", _input)  # OK
+    re.fullmatch(r"\s*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"\s*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.search(r"\s*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.fullmatch(r"[a\s]*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"[a\s]*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.search(r"[a\s]*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.fullmatch(r"[a\s]*b*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"[a\s]*b*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.search(r"[a\s]*b*\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+
+
+def implicit_reluctant_quantifier_in_partial_match(_input):
+    re.search(r"\s*,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"\s*,", _input)  # OK
+    re.fullmatch(r"\s*,", _input)  # OK
+    re.search(r"\s*+,", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"\s*+,", _input)  # OK
+    re.fullmatch(r"\s*+,", _input)  # OK
+    re.search(r"(?s:.*)\s*,(?s:.*)", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"(?s:.*)\s*,(?s:.*)", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.fullmatch(r"(?s:.*)\s*,(?s:.*)", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.search(r"(?s:.*)\s*+,(?s:.*)", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"(?s:.*)\s*+,(?s:.*)", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.fullmatch(r"(?s:.*)\s*+,(?s:.*)", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+
+
+def different_polynomials(_input):
+    re.fullmatch(r"x*x*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"x*x*", _input)  # OK
+    re.search(r"x*x*", _input)  # OK
+    re.fullmatch(r"x*x*x*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"x*x*x*", _input)  # OK
+    re.search(r"x*x*x*", _input)  # OK
+    re.fullmatch(r"x*x*x*x*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"x*x*x*x*", _input)  # OK
+    re.search(r"x*x*x*x*", _input)  # OK
+    re.fullmatch(r"x*x*x*x*x*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"x*x*x*x*x*", _input)  # OK
+    re.search(r"x*x*x*x*x*", _input)  # OK
+    re.fullmatch(r"[^=]*.*.*=.*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.match(r"[^=]*.*.*=.*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.search(r"[^=]*.*.*=.*", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.search(r"a+b", _input) # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+
+
+def linear_when_optimized_reported_by_s5852(_input):
+    re.search(r"(.?,)*X", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.search(r"(.?,)*\1", _input)  # Noncompliant  {{Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.}}
+    re.fullmatch(r"(.?,)*X", _input)  # OK, LINEAR_WHEN_OPTIMIZED reported by S5852
+    re.match(r"(.?,)*X", _input)  # OK
+    re.fullmatch(r"(.?,)*\1", _input)  # OK
+    re.match(r"(.?,)*\1", _input)  # OK
+
+
+def should_not_report_exponential_cases(_input):
+    re.fullmatch(r"(.*,)*?", _input)  # OK, exponential cases reported by S5852
+    re.fullmatch(r"(.*,)*", _input)  # OK
+    re.fullmatch(r"(.*,)*X", _input)  # OK
+    re.match(r"(.*,)*X", _input)  # OK
+    re.search(r"(.*,)*X", _input)  # OK
+
+
+def compliant(_input):
+    re.fullmatch(r"abc", _input)
+    re.fullmatch(r"(?s)(.*,)*.*", _input)
+    re.fullmatch(r"(?:(.)\1)*", _input)
diff --git a/python-checks/src/test/resources/checks/returnAndYieldInOneFunction.py b/python-checks/src/test/resources/checks/returnAndYieldInOneFunction.py
index 53bfc659ec..bc0a265729 100644
--- a/python-checks/src/test/resources/checks/returnAndYieldInOneFunction.py
+++ b/python-checks/src/test/resources/checks/returnAndYieldInOneFunction.py
@@ -1,5 +1,4 @@
-
-def fun1(n): # Noncompliant {{Use only "return" or only "yield", not both.}}
+def fun1(n):  # Noncompliant {{Only yield or return values from this function, not both.}}
 #   ^^^^
     num = 0
     while num < n:
@@ -22,7 +21,8 @@ def fun3(n):
         yield num
         num += 1
 
-def fun5(n): # Noncompliant
+
+def fun5(n):  # Noncompliant
     num = 0
     if n == 0:
         return
@@ -31,18 +31,23 @@ def fun5(n): # Noncompliant
         num += 1
     return num
 
+
 def fun4(n):
     num = 0
     while num < n:
         num += 1
     return num
 
+
 def fun6():
     def fun7():
         yield 1
+
     return 1
 
+
 def fun8():
     def fun9():
         return 1
+
     yield 1
diff --git a/python-checks/src/test/resources/checks/setDiscardOverRemove.py b/python-checks/src/test/resources/checks/setDiscardOverRemove.py
new file mode 100644
index 0000000000..2bcfa65445
--- /dev/null
+++ b/python-checks/src/test/resources/checks/setDiscardOverRemove.py
@@ -0,0 +1,191 @@
+def basic_set_literal(x):
+    my_set = {1, 2, 3}
+    if x in my_set:  # Noncompliant {{Use "discard()" instead of checking membership before calling "remove()".}}
+    #  ^^^^^^^^^^^
+        my_set.remove(x)
+
+
+def basic_set_constructor(x):
+    my_set = set([1, 2, 3])
+    if x in my_set:  # Noncompliant
+        my_set.remove(x)
+
+
+def multiple_operations_in_body(x):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        my_set.remove(x)
+        print("removed")  # additional logic
+
+
+def else_branch_present(x):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        my_set.remove(x)
+    else:
+        print("not found")
+
+
+def elif_branch_present(x, y):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        my_set.remove(x)
+    elif y in my_set:
+        my_set.remove(y)
+
+
+def not_in_condition(x):
+    my_set = {1, 2, 3}
+    if x not in my_set:
+        my_set.remove(x)
+
+
+def different_objects(x):
+    set_a = {1, 2, 3}
+    set_b = {4, 5, 6}
+    if x in set_a:
+        set_b.remove(x)
+
+
+def different_elements(x, y):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        my_set.remove(y)
+
+
+def list_not_set(x):
+    my_list = [1, 2, 3]
+    if x in my_list:
+        my_list.remove(x)
+
+
+def dict_not_set(x):
+    my_dict = {"a": 1}
+    if x in my_dict:
+        my_dict.pop(x)
+
+
+def frozenset_type(x):
+    my_fset = frozenset([1, 2, 3])
+    if x in my_fset:  # frozenset has no remove()
+        ...
+
+
+def not_a_remove_call(x):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        my_set.add(x + 1)
+
+
+def complex_condition(x, flag):
+    my_set = {1, 2, 3}
+    if x in my_set and flag:
+        my_set.remove(x)
+
+
+def set_from_parameter(my_set: set, x):
+    if x in my_set:  # Noncompliant
+        my_set.remove(x)
+
+
+def set_subclass(x):
+    class MySet(set):
+        pass
+    s = MySet()
+    if x in s:  # Noncompliant
+        s.remove(x)
+
+
+def method_call_on_self(x):
+    class Container:
+        def __init__(self):
+            self.items = {1, 2, 3}
+
+        def remove_item(self, value):
+            if value in self.items:  # FN: type of self.items attribute is not inferred
+                self.items.remove(value)
+
+
+def nested_attribute_access(x):
+    class Container:
+        pass
+    c = Container()
+    c.items = {1, 2, 3}
+    if x in c.items:  # FN: type of c.items attribute is not inferred
+        c.items.remove(x)
+
+
+def remove_with_wrong_number_of_args(x, y):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        my_set.remove(x, y)  # FN: invalid set.remove call, but not our rule's concern
+
+
+def complex_element_expression(items, i):
+    my_set = {1, 2, 3}
+    if items[i] in my_set:  # Noncompliant
+        my_set.remove(items[i])
+
+
+def body_is_not_expression_statement(x):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        return
+
+
+def body_is_pass_statement(x):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        pass
+
+
+def body_is_assignment(x):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        y = my_set.remove(x)
+
+
+def body_has_multiple_expressions(x):
+    my_set = {1, 2, 3}
+    def foo(): ...
+    if x in my_set:
+        my_set.remove(x), foo()
+
+
+def bare_remove_call(x):
+    def remove(value): ...
+    my_set = {1, 2, 3}
+    if x in my_set:
+        remove(x)
+
+
+def remove_with_unpacking_argument(x):
+    my_set = {1, 2, 3}
+    args = (x,)
+    if x in my_set:
+        my_set.remove(*args)
+
+
+def remove_with_keyword_argument(x):
+    my_set = {1, 2, 3}
+    if x in my_set:
+        my_set.remove(element=x)
+
+
+def multiline_qualifier(x, cond):
+    my_set = {1, 2, 3}
+    other_set = {4, 5, 6}
+    if x in (my_set  # Noncompliant
+             if cond else
+             other_set):
+        (my_set
+         if cond else
+         other_set).remove(x)
+
+
+def multiline_argument(items, i):
+    my_set = {1, 2, 3}
+    if items[  # Noncompliant
+            i] in my_set:
+        my_set.remove(items[
+                          i])
diff --git a/python-checks/src/test/resources/checks/setUpdateOverForLoop.py b/python-checks/src/test/resources/checks/setUpdateOverForLoop.py
new file mode 100644
index 0000000000..f209ca1554
--- /dev/null
+++ b/python-checks/src/test/resources/checks/setUpdateOverForLoop.py
@@ -0,0 +1,161 @@
+
+def noncompliant_basic():
+    my_set = {1, 2, 3}
+    other_collection = [4, 5, 6]
+    for element in other_collection:
+        my_set.add(element)  # Noncompliant {{Use "set.update()" instead of a for-loop with "add()".}}
+    #   ^^^^^^^^^^
+
+
+def noncompliant_multiline_iterable():
+    my_set = set()
+    for element in [
+        1,
+        2,
+        3,
+    ]:
+        my_set.add(element)  # Noncompliant
+    #   ^^^^^^^^^^
+
+
+def noncompliant_multiline_receiver():
+    my_set = set()
+    items = [1, 2, 3]
+    for item in items:
+        (my_set  # Noncompliant
+         ).add(item)
+
+
+def compliant_tuple_unpacking_loop_var():
+    my_set = set()
+    pairs = [(1, "a"), (2, "b")]
+    for k, v in pairs:
+        my_set.add(k)
+
+
+def compliant_tuple_pattern_loop_var():
+    my_set = set()
+    pairs = [(1, 2), (3, 4)]
+    for (a, b) in pairs:
+        my_set.add(a)
+
+
+def compliant_multiple_iterables():
+    my_set = set()
+    a = [1, 2]
+    b = [3, 4]
+    for x in a, b:
+        my_set.add(x)
+
+
+def compliant_multiple_body_statements():
+    my_set = set()
+    log = []
+    items = [1, 2, 3]
+    for item in items:
+        log.append(item)
+        my_set.add(item)
+
+
+def compliant_conditional_in_body():
+    my_set = set()
+    items = range(10)
+    for item in items:
+        if item % 2 == 0:
+            my_set.add(item)
+
+
+def compliant_expression_tuple_in_body():
+    my_set = set()
+    items = [1, 2, 3]
+    for item in items:
+        item, item
+
+
+def compliant_non_call_in_body():
+    my_set = set()
+    items = [1, 2, 3]
+    for item in items:
+        item
+
+
+def compliant_bare_function_call():
+    my_set = set()
+    items = [1, 2, 3]
+    for item in items:
+        print(item)
+
+
+def compliant_method_not_add():
+    my_set = set()
+    items = [1, 2, 3]
+    for item in items:
+        my_set.discard(item)
+
+
+def get_set():
+    return set()
+
+
+def compliant_receiver_is_call():
+    items = [1, 2, 3]
+    for item in items:
+        get_set().add(item)
+
+
+def compliant_unknown_receiver_type(unknown_receiver, items):
+    for item in items:
+        unknown_receiver.add(item)
+
+
+def compliant_no_argument():
+    my_set = set()
+    for item in [1, 2, 3]:
+        my_set.add()
+
+
+def compliant_starred_argument():
+    my_set = set()
+    args = (1,)
+    for item in [1, 2, 3]:
+        my_set.add(*args)
+
+
+def compliant_keyword_argument():
+    my_set = set()
+    for item in [1, 2, 3]:
+        my_set.add(elem=item)
+
+
+def compliant_transformed_argument():
+    my_set = set()
+    items = [1, 2, 3]
+    for item in items:
+        my_set.add(item * 2)
+
+
+def compliant_different_variable():
+    my_set = set()
+    other = "fixed_value"
+    items = [1, 2, 3]
+    for item in items:
+        my_set.add(other)
+
+
+def compliant_for_else():
+    my_set = set()
+    items = [1, 2, 3]
+    for item in items:
+        my_set.add(item)
+    else:
+        fallback()
+
+
+class MyClass:
+    def __init__(self):
+        self.seen: set = set()
+
+    def process(self, items):
+        # FN: instance attribute type not inferred across methods
+        for item in items:
+            self.seen.add(item)
diff --git a/python-checks/src/test/resources/checks/singleDispatchMixup.py b/python-checks/src/test/resources/checks/singleDispatchMixup.py
new file mode 100644
index 0000000000..053d0cdefe
--- /dev/null
+++ b/python-checks/src/test/resources/checks/singleDispatchMixup.py
@@ -0,0 +1,64 @@
+from functools import singledispatch, singledispatchmethod
+
+
+class WithSingledispatch:
+    @singledispatch  # Noncompliant {{Use "@singledispatchmethod" instead of "@singledispatch" on methods defined in a class body.}}
+   #^^^^^^^^^^^^^^^
+    def process(self, data):
+        pass
+
+
+class WithWrongStaticmethodOrder:
+    @singledispatch  # Noncompliant {{Use "@singledispatchmethod" instead of "@singledispatch" on methods defined in a class body.}}
+    @staticmethod
+    def handle(data):
+        pass
+
+
+@singledispatchmethod  # Noncompliant {{Use "@singledispatch" instead of "@singledispatchmethod" on standalone functions.}}
+#^[sc=1;ec=21]
+def process_standalone(data):
+    pass
+
+
+@singledispatch
+def compliant_standalone(data):
+    pass
+
+
+class WithSingledispatchmethod:
+    @singledispatchmethod
+    def process(self, data):
+        pass
+
+
+class WithValidStaticmethodOrder:
+    @staticmethod
+    @singledispatch
+    def process(data):
+        pass
+
+
+class WithClassmethodAndSingledispatch:
+    @singledispatch  # Noncompliant {{Use "@singledispatchmethod" instead of "@singledispatch" on methods defined in a class body.}}
+    @classmethod
+    def handle(cls, data):
+        pass
+
+
+class WithSingledispatchmethodAndClassmethod:
+    @singledispatchmethod
+    @classmethod
+    def process(cls, data):
+        pass
+
+
+class WithNestedFunction:
+    def outer(self):
+        @singledispatch  # Compliant: nested function, not a method definition
+        def inner(data):
+            pass
+
+
+def no_dispatch(data):
+    pass
diff --git a/python-checks/src/test/resources/checks/sklearn_cached_pipeline_dont_access_transformers.py b/python-checks/src/test/resources/checks/sklearn_cached_pipeline_dont_access_transformers.py
index 84e8dd0ae5..183de0c656 100644
--- a/python-checks/src/test/resources/checks/sklearn_cached_pipeline_dont_access_transformers.py
+++ b/python-checks/src/test/resources/checks/sklearn_cached_pipeline_dont_access_transformers.py
@@ -4,6 +4,7 @@
 from sklearn.pipeline import Pipeline, make_pipeline
 from sklearn.preprocessing import PolynomialFeatures
 from sklearn.decomposition import FastICA
+from sklearn.some_import import cache
 
 
 def case1():
@@ -82,7 +83,7 @@ def case5():
     pca3 = PCA()
     pipel = Pipeline([(clever_generator())])
 
-def case5():
+def case6():
     from sklearn.pipeline import Pipeline
     from sklearn.preprocessing import StandardScaler
     from sklearn.decomposition import PCA
@@ -96,3 +97,16 @@ class SomeKindOfRecord():
     obj.pipeline =  Pipeline([('scaler', scaler), ('pca', pca)], memory="cache") # Noncompliant
 
     scaler.szsdgf_ = 12
+
+
+def unknown_cache_import():
+    diabetes = load_diabetes()
+    scaler = RobustScaler()
+    knn = KNeighborsRegressor(n_neighbors=5)
+
+    pipeline = Pipeline([
+        ('scaler', scaler), 
+        ('knn', knn)
+    ], memory=cache) # Cannot resolve cache 
+
+    print(scaler.center_)
diff --git a/python-checks/src/test/resources/checks/slotsAssignment.py b/python-checks/src/test/resources/checks/slotsAssignment.py
new file mode 100644
index 0000000000..8ca0a732e2
--- /dev/null
+++ b/python-checks/src/test/resources/checks/slotsAssignment.py
@@ -0,0 +1,832 @@
+class UserBasic:
+    __slots__ = ['name', 'email']
+
+    def __init__(self, name, email, age):
+        self.name = name
+        self.email = email
+        self.age = age  # Noncompliant {{Add "age" to the class's "__slots__".}}
+#            ^^^
+
+
+# Multiple missing attributes in same __init__
+class UserMultipleMissing:
+    __slots__ = ['name']
+
+    def __init__(self, name, email, age):
+        self.name = name
+        self.email = email  # Noncompliant {{Add "email" to the class's "__slots__".}}
+#            ^^^^^
+        self.age = age  # Noncompliant {{Add "age" to the class's "__slots__".}}
+#            ^^^
+
+
+# Missing attribute in a non-__init__ method
+class Point:
+    __slots__ = ['x', 'y']
+
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def set_z(self, z):
+        self.z = z  # Noncompliant {{Add "z" to the class's "__slots__".}}
+#            ^
+
+
+# __slots__ as tuple
+class PointTuple:
+    __slots__ = ('x', 'y')
+
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z  # Noncompliant {{Add "z" to the class's "__slots__".}}
+#            ^
+
+
+# Empty __slots__
+class EmptySlots:
+    __slots__ = []
+
+    def __init__(self, value):
+        self.value = value  # Noncompliant
+#            ^^^^^
+
+
+# Missing attribute in a property setter
+class TemperatureWithBadCache:
+    __slots__ = ['_celsius']
+
+    def __init__(self, celsius):
+        self._celsius = celsius
+
+    @property
+    def fahrenheit(self):
+        return self._celsius * 9 / 5 + 32
+
+    @fahrenheit.setter
+    def fahrenheit(self, value):
+        self._celsius = (value - 32) * 5 / 9
+        self._fahrenheit_cache = value  # Noncompliant
+#            ^^^^^^^^^^^^^^^^^
+
+
+# Augmented assignment not in __slots__
+class Counter:
+    __slots__ = ['count']
+
+    def __init__(self):
+        self.count = 0
+
+    def increment(self):
+        self.total += 1  # Noncompliant
+#            ^^^^^
+
+
+# __slots__ as dict
+class LinkedNode:
+    __slots__ = {'value': 'The node value', 'next': 'The next node'}
+
+    def __init__(self, value, next_node=None, extra=None):
+        self.value = value
+        self.next = next_node
+        self.extra = extra  # Noncompliant
+#            ^^^^^
+
+
+# Assignment inside a conditional block
+class Config:
+    __slots__ = ['host', 'port']
+
+    def __init__(self, host, port, debug=False):
+        self.host = host
+        self.port = port
+        if debug:
+            self.debug_info = "enabled"  # Noncompliant
+#                ^^^^^^^^^^
+
+
+# Subclass — attribute not in current or parent __slots__
+class Base:
+    __slots__ = ['base_attr']
+
+    def __init__(self):
+        self.base_attr = 1
+
+
+class DerivedMissingAttr(Base):
+    __slots__ = ['derived_attr']
+
+    def __init__(self):
+        super().__init__()
+        self.derived_attr = 2
+        self.other_attr = 3  # Noncompliant
+#            ^^^^^^^^^^
+
+
+# Augmented assignment not in any class's __slots__
+class BaseWithCount:
+    __slots__ = ['count']
+
+    def __init__(self):
+        self.count = 0
+
+
+class DerivedAugmented(BaseWithCount):
+    __slots__ = ['name']
+
+    def update(self):
+        self.count += 1  # Compliant: in parent slots
+        self.missing += 1  # Noncompliant
+#            ^^^^^^^
+
+
+# Assignment inside a loop body
+class Accumulator:
+    __slots__ = ['total']
+
+    def __init__(self):
+        self.total = 0
+
+    def process(self, items):
+        for item in items:
+            self.total += item
+            self.last_item = item  # Noncompliant
+#                ^^^^^^^^^
+
+
+# Non-standard self parameter name
+class WeirdSelf:
+    __slots__ = ['value']
+
+    def __init__(this, value):
+        this.value = value
+        this.extra = 42  # Noncompliant
+#            ^^^^^
+
+
+# Chained assignment — second target not in __slots__
+class MultiAssign:
+    __slots__ = ['x']
+
+    def setup(self):
+        self.x = self.y = 0  # Noncompliant
+#                     ^
+
+
+# Compliant: all attributes in __slots__
+class UserCompliant:
+    __slots__ = ['name', 'email', 'age']
+
+    def __init__(self, name, email, age):
+        self.name = name
+        self.email = email
+        self.age = age
+
+
+# Compliant: no __slots__ means no restriction
+class NoSlots:
+    def __init__(self, name, value, extra):
+        self.name = name
+        self.value = value
+        self.extra = extra
+        self.anything = True
+
+
+# Compliant: assigning to other.attr (not self)
+class NodeCompliant:
+    __slots__ = ['value', 'next']
+
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+
+    def append(self, other):
+        other.value = self.value
+        other.next = None
+        other.extra = 42
+
+
+# Compliant: parent without __slots__ provides __dict__ to child
+class ParentWithoutSlots:
+    def __init__(self):
+        self.parent_value = 0
+
+
+class ChildInheritsDict(ParentWithoutSlots):
+    __slots__ = ['extra']
+
+    def __init__(self):
+        super().__init__()
+        self.extra = 1
+        self.anything = True  # Compliant: parent provides __dict__
+
+
+# Compliant: __slots__ contains '__dict__'
+class WithDictSlot:
+    __slots__ = ['name', '__dict__']
+
+    def __init__(self, name):
+        self.name = name
+        self.dynamic_attr = "anything goes"
+        self.other = 42
+
+
+# Compliant: current + parent slots cover all assignments
+class ShapeBase:
+    __slots__ = ['color']
+
+    def __init__(self, color):
+        self.color = color
+
+
+class Circle(ShapeBase):
+    __slots__ = ['radius']
+
+    def __init__(self, color, radius):
+        super().__init__(color)
+        self.radius = radius
+
+    def scale(self, factor):
+        self.radius *= factor
+
+
+# Compliant: @staticmethod skipped
+class MathHelper:
+    __slots__ = ['value']
+
+    def __init__(self, value):
+        self.value = value
+
+    @staticmethod
+    def add(a, b):
+        result = a + b
+        return result
+
+
+# Compliant: @classmethod skipped
+class Registry:
+    __slots__ = ['name']
+
+    def __init__(self, name):
+        self.name = name
+
+    @classmethod
+    def create(cls, name):
+        obj = cls.__new__(cls)
+        return obj
+
+
+# Compliant: tuple __slots__ covers all attributes
+class PointTupleCompliant:
+    __slots__ = ('x', 'y', 'z')
+
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+
+
+# Compliant: dict __slots__ covers all attributes
+class LinkedNodeCompliant:
+    __slots__ = {'value': 'The node value', 'next': 'The next node'}
+
+    def __init__(self, value, next_node=None):
+        self.value = value
+        self.next = next_node
+
+
+# Compliant: property setter assigns only to slots attributes
+class TemperatureCompliant:
+    __slots__ = ['_celsius']
+
+    def __init__(self, celsius):
+        self._celsius = celsius
+
+    @property
+    def fahrenheit(self):
+        return self._celsius * 9 / 5 + 32
+
+    @fahrenheit.setter
+    def fahrenheit(self, value):
+        self._celsius = (value - 32) * 5 / 9
+
+
+# FN accepted: dynamic __slots__ — rule bails
+def compute_slots():
+    return ['x', 'y']
+
+
+class DynamicSlots:
+    __slots__ = compute_slots()
+
+    def __init__(self):
+        self.x = 1
+        self.z = 2  # FN: __slots__ not a literal
+
+
+# Compliant: qualifier is subscript, not a name
+class NoParams:
+    __slots__ = ['value']
+
+    def unusual_method(*args):
+        args[0].value = 1
+        args[0].extra = 2
+
+
+# Compliant: nested function not analyzed
+class WithNestedFunction:
+    __slots__ = ['value']
+
+    def __init__(self, value):
+        self.value = value
+
+        def inner(self):
+            self.anything = True  # not visited
+
+
+# FN accepted: indirect self reference not tracked
+class SelfAlias:
+    __slots__ = ['value']
+
+    def __init__(self):
+        obj = self
+        obj.value = 1
+        obj.missing = 2  # FN: qualifier is 'obj'
+
+
+# Compliant: qualifier of 'value' is 'self.child', not 'self'
+class DeepChain:
+    __slots__ = ['child']
+
+    def __init__(self):
+        self.child = None
+        self.child.value = 10
+
+
+# Compliant: __dict__ in __slots__ lifts restriction
+class OnlyDictSlot:
+    __slots__ = ['__dict__']
+
+    def __init__(self):
+        self.anything = True
+        self.more = "hello"
+
+
+# Compliant: grandparent has no __slots__, __dict__ available
+class GrandParentNoSlots:
+    pass
+
+
+class ParentWithSlots(GrandParentNoSlots):
+    __slots__ = ['parent_val']
+
+
+class GrandChildWithSlots(ParentWithSlots):
+    __slots__ = ['child_val']
+
+    def __init__(self):
+        self.child_val = 1
+        self.parent_val = 2
+        self.anything = 3  # Compliant: grandparent provides __dict__
+
+
+# Variable references in __slots__ resolved via single-assignment analysis
+SLOT_NAME = 'value'
+
+
+class NonStringSlots:
+    __slots__ = [SLOT_NAME, 'other']
+
+    def __init__(self):
+        self.value = 1
+        self.missing = 2  # Noncompliant {{Add "missing" to the class's "__slots__".}}
+#            ^^^^^^^
+
+
+class NonStringTupleSlots:
+    __slots__ = (SLOT_NAME, 'other')
+
+    def __init__(self):
+        self.value = 1
+        self.missing = 2  # Noncompliant {{Add "missing" to the class's "__slots__".}}
+#            ^^^^^^^
+
+
+# FN accepted: dict unpacking element in __slots__ dict — rule bails
+extra = {'z': 'extra'}
+
+
+class DictUnpackingSlots:
+    __slots__ = {'x': 'x coord', **extra}
+
+    def __init__(self):
+        self.x = 1
+        self.missing = 2  # FN: unpacking in __slots__ dict
+
+
+# FN accepted: non-string key in __slots__ dict — rule bails
+class NonStringKeyDictSlots:
+    __slots__ = {1: 'one', 'other': 'two'}
+
+    def __init__(self):
+        self.other = 1
+        self.missing = 2  # FN: non-string key in __slots__ dict
+
+
+# Compliant: class has unresolved type hierarchy (inherits from unknown external class)
+from unknown_module import ExternalBase  # noqa
+
+
+class InheritsFromUnknown(ExternalBase):
+    __slots__ = ['value']
+
+    def __init__(self, value):
+        self.value = value
+        self.extra = 42  # Compliant: unresolved hierarchy, rule bails
+
+
+# Compliant: method with only keyword-only parameters (no positional params)
+class KeywordOnlyMethod:
+    __slots__ = ['value']
+
+    def __init__(self, value):
+        self.value = value
+
+    def update(self, *, kwarg):
+        result = kwarg
+        return result
+
+
+# Compliant: chained __slots__ assignment (lhsExpressions.size() > 1) — rule bails
+class ChainedSlotsAssignment:
+    __slots__ = other_var = ['value']
+
+    def __init__(self):
+        self.value = 1
+        self.extra = 2  # FN: chained assignment makes __slots__ unrecognized
+
+
+# Compliant: tuple-unpack LHS on __slots__ assignment (lhs.size() != 1) — rule bails
+class TupleUnpackLhsSlots:
+    a, b = 1, 2  # lhs expressions list has 2 elements, skipped
+    __slots__ = ['value']
+
+    def __init__(self):
+        self.value = 1
+
+
+# Compliant: LHS is a list literal wrapping a name (lhs.size() == 1, not a NAME) — rule bails
+class ListWrapLhsSlots:
+    [__slots__] = [['value']]
+
+    def __init__(self):
+        self.value = 1
+        self.extra = 2  # FN: list-wrap LHS makes __slots__ unrecognized
+
+
+# Compliant: non-__slots__ assignment in class body does not confuse the check
+class WithOtherClassVar:
+    class_var = 42
+    __slots__ = ['value']
+
+    def __init__(self, value):
+        self.value = value
+
+
+# Compliant: parent has __dict__ in its __slots__, providing __dict__ to child
+class ParentWithDictSlot:
+    __slots__ = ['parent_val', '__dict__']
+
+    def __init__(self):
+        self.parent_val = 0
+
+
+class ChildOfParentWithDictSlot(ParentWithDictSlot):
+    __slots__ = ['child_val']
+
+    def __init__(self):
+        super().__init__()
+        self.child_val = 1
+        self.anything = True  # Compliant: parent has __dict__ in slots
+
+
+# Compliant: explicit object inheritance — object is skipped in ancestor collection
+class ExplicitObjectBase(object):
+    __slots__ = ['value']
+
+    def __init__(self, value):
+        self.value = value
+
+
+# Inherits from built-in list — external parent has no local ClassDef
+class InheritsFromBuiltin(list):
+    __slots__ = ['label']
+
+    def __init__(self, label):
+        super().__init__()
+        self.label = label
+        self.extra = 42  # Noncompliant
+
+
+# Compliant: method with no parameters at all (parameterList is null -> positional params empty)
+class NoParamMethod:
+    __slots__ = ['value']
+
+    def __init__(self, value):
+        self.value = value
+
+    def no_params():
+        pass
+
+
+# Compliant: LHS in class body is a subscript (not a Name) — skipped by extractOwnSlots
+class LhsSubscriptInBody:
+    _registry = {}
+    _registry['key'] = 'registered'
+    __slots__ = ['value']
+
+    def __init__(self, value):
+        self.value = value
+
+
+# Compliant: parent is a dynamically-assigned name with no FQN — skipped in ancestor collection
+def make_dynamic_base():
+    class _Inner:
+        __slots__ = ['x']
+    return _Inner
+
+
+DynamicBase = make_dynamic_base()
+
+
+class InheritsDynamicBase(DynamicBase):
+    __slots__ = ['y']
+
+    def __init__(self, x, y):
+        self.x = x  # Compliant: DynamicBase parent is skipped (fqn is null)
+        self.y = y
+
+
+# Compliant: class with ambiguous symbol (defined in both branches) — getClassSymbolFromDef returns null
+import sys as _sys
+
+if _sys.version_info[0] >= 3:
+    class VersionedClass:
+        __slots__ = ['x']
+
+        def __init__(self):
+            self.x = 1
+else:
+    class VersionedClass:  # noqa
+        __slots__ = ['x']
+
+        def __init__(self):
+            self.x = 1
+
+
+# Compliant: parent class is ambiguously defined (same FQN) — parentClassSymbol is null
+if _sys.version_info[0] >= 3:
+    class AmbiguousParent:
+        __slots__ = ['parent_val']
+else:
+    class AmbiguousParent:  # noqa
+        __slots__ = ['parent_val']
+
+
+class InheritsAmbiguousParent(AmbiguousParent):
+    __slots__ = ['child_val']
+
+    def __init__(self):
+        self.parent_val = 1
+        self.child_val = 2
+
+
+# __slots__ as set literal — now supported
+class SetSlots:
+    __slots__ = {'name', 'value'}
+
+    def __init__(self, name, value, extra):
+        self.name = name
+        self.value = value
+        self.extra = extra  # Noncompliant {{Add "extra" to the class's "__slots__".}}
+#            ^^^^^
+
+
+# Compliant: set literal __slots__ covers all attributes
+class SetSlotsCompliant:
+    __slots__ = {'x', 'y', 'z'}
+
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+
+
+# Variable reference in set literal __slots__ resolved via single-assignment analysis
+class NonStringSetSlots:
+    __slots__ = {SLOT_NAME, 'other'}
+
+    def __init__(self):
+        self.other = 1
+        self.missing = 2  # Noncompliant {{Add "missing" to the class's "__slots__".}}
+#            ^^^^^^^
+
+
+# __slots__ as single string — now supported
+class SingleStringSlots:
+    __slots__ = 'value'
+
+    def __init__(self, value, extra):
+        self.value = value
+        self.extra = extra  # Noncompliant {{Add "extra" to the class's "__slots__".}}
+#            ^^^^^
+
+
+# Compliant: single string __slots__ covers the attribute
+class SingleStringSlotsCompliant:
+    __slots__ = 'value'
+
+    def __init__(self, value):
+        self.value = value
+
+
+# Multiple __slots__ assignments — last one wins
+class MultipleSlotsAssignments:
+    __slots__ = ['x', 'y', 'z']
+    __slots__ = ['x']
+
+    def __init__(self):
+        self.x = 1
+        self.y = 2  # Noncompliant {{Add "y" to the class's "__slots__".}}
+#            ^
+
+
+# Multiple __slots__ assignments — last one is larger
+class MultipleSlotsLarger:
+    __slots__ = ['x']
+    __slots__ = ['x', 'y', 'z']
+
+    def __init__(self):
+        self.x = 1
+        self.y = 2
+        self.z = 3
+
+
+# Compliant: nested class inside method does not cause false positives
+class OuterWithNestedClass:
+    __slots__ = ['x']
+
+    def method(self):
+        self.x = 1
+        class Inner:
+            def __init__(inner_self):
+                inner_self.y = 1  # Compliant: visitor stops at nested class
+
+
+# Diamond inheritance — slots from all branches are allowed
+class DiamondBase:
+    __slots__ = ['base_attr']
+
+class DiamondLeft(DiamondBase):
+    __slots__ = ['left_attr']
+
+class DiamondRight(DiamondBase):
+    __slots__ = ['right_attr']
+
+class DiamondChild(DiamondLeft, DiamondRight):
+    __slots__ = ['child_attr']
+
+    def __init__(self):
+        self.base_attr = 1   # Compliant: from DiamondBase via DiamondLeft
+        self.left_attr = 2   # Compliant: from DiamondLeft
+        self.right_attr = 3  # Compliant: from DiamondRight
+        self.child_attr = 4  # Compliant: own slot
+        self.missing = 5     # Noncompliant {{Add "missing" to the class's "__slots__".}}
+#            ^^^^^^^
+
+# Compliant: parent class from different file — can't determine its __slots__
+from collections import OrderedDict
+
+class CustomOrderedDict(OrderedDict):
+    __slots__ = ['label']
+
+    def __init__(self, label):
+        super().__init__()
+        self.label = label
+        self.extra = 42  # Compliant: can't inspect external parent's __slots__
+
+
+# FN accepted: empty tuple __slots__
+class EmptyTupleSlots:
+    __slots__ = ()
+
+    def __init__(self, value):
+        self.value = value  # Noncompliant {{Add "value" to the class's "__slots__".}}
+#            ^^^^^
+
+
+# FN accepted: function call element in __slots__ list — rule bails
+class FuncCallInSlots:
+    __slots__ = ['name', some_func()]
+
+    def __init__(self):
+        self.name = 1
+        self.missing = 2  # FN: function call in __slots__ list
+
+
+# FN accepted: integer literal element in __slots__ list — rule bails
+class IntLiteralInSlots:
+    __slots__ = ['name', 42]
+
+    def __init__(self):
+        self.name = 1
+        self.missing = 2  # FN: non-string literal in __slots__ list
+
+
+# FN accepted: star-unpacking element in __slots__ list — rule bails
+base_slots = ['x', 'y']
+
+
+class StarUnpackingInSlots:
+    __slots__ = [*base_slots, 'z']
+
+    def __init__(self):
+        self.z = 1
+        self.missing = 2  # FN: star-unpacking in __slots__ list
+
+
+# FN accepted: unresolvable variable in __slots__ — rule bails
+from unknown_module import EXTERNAL_SLOT  # noqa
+
+
+class UnresolvableVarInSlots:
+    __slots__ = ['name', EXTERNAL_SLOT]
+
+    def __init__(self):
+        self.name = 1
+        self.missing = 2  # FN: variable can't be resolved
+
+
+# FN accepted: variable resolves to non-string value — rule bails
+MY_INT_VAR = 42
+
+
+class VarResolvesToNonString:
+    __slots__ = ['name', MY_INT_VAR]
+
+    def __init__(self):
+        self.name = 1
+        self.missing = 2  # FN: variable resolves to int, not string
+
+
+# FN accepted: variable assigned multiple times — rule bails
+if _sys.version_info[0] >= 3:
+    AMBIGUOUS_SLOT = 'x'
+else:
+    AMBIGUOUS_SLOT = 'y'
+
+
+class AmbiguousVarInSlots:
+    __slots__ = ['name', AMBIGUOUS_SLOT]
+
+    def __init__(self):
+        self.name = 1
+        self.missing = 2  # FN: variable has multiple assignments
+
+
+# FN accepted: concatenation expression in __slots__ — rule bails
+class ConcatenatedSlots:
+    __slots__ = ['x'] + ['y']
+
+    def __init__(self):
+        self.x = 1
+        self.missing = 2  # FN: __slots__ is a binary expression, not a literal
+
+# Compliant: __slots__ uses mangled names and assignments use double-underscore syntax
+class Rat(object):
+    __slots__ = ['_Rat__num', '_Rat__den']
+
+    def __init__(self, num=0, den=1):
+        self.__num = num  # Compliant: stored as _Rat__num, which is in __slots__
+        self.__den = den  # Compliant: stored as _Rat__den, which is in __slots__
+
+
+# Issue raised when attribute is not in slots even with partial mangled entries
+class RatMissing(object):
+    __slots__ = ['_RatMissing__num']
+
+    def __init__(self, num=0, den=1):
+        self.__num = num  # Compliant: stored as _RatMissing__num, which is in __slots__
+        self.__den = den  # Noncompliant {{Add "__den" to the class's "__slots__".}}
+#            ^^^^^
+
+
+# Compliant: class name starts with underscore — mangling strips leading underscores from class name
+# Python mangles _Rat.__den to _Rat__den (not __Rat__den)
+class _Rat(object):
+    __slots__ = ['_Rat__num', '_Rat__den']
+
+    def __init__(self, num=0, den=1):
+        self.__num = num  # Compliant: stored as _Rat__num, which is in __slots__
+        self.__den = den  # Compliant: stored as _Rat__den, which is in __slots__
diff --git a/python-checks/src/test/resources/checks/sortedMinMax.py b/python-checks/src/test/resources/checks/sortedMinMax.py
new file mode 100644
index 0000000000..3c3349a40d
--- /dev/null
+++ b/python-checks/src/test/resources/checks/sortedMinMax.py
@@ -0,0 +1,126 @@
+numbers = [42, 17, 93, 8, 51]
+words = ["banana", "fig", "apple", "date"]
+
+# Issues detected
+smallest = sorted(numbers)[0]  # Noncompliant {{Use "min()" instead of sorting to find this value.}}
+#          ^^^^^^^^^^^^^^^^^^
+
+largest = sorted(numbers)[-1]  # Noncompliant {{Use "max()" instead of sorting to find this value.}}
+#         ^^^^^^^^^^^^^^^^^^^
+
+also_largest = sorted(numbers, reverse=True)[0]  # Noncompliant {{Use "max()" instead of sorting to find this value.}}
+#              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+also_smallest = sorted(numbers, reverse=True)[-1]  # Noncompliant {{Use "min()" instead of sorting to find this value.}}
+#               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+# reverse=False is treated the same as no reverse argument
+x = sorted(numbers, reverse=False)[0]  # Noncompliant {{Use "min()" instead of sorting to find this value.}}
+y = sorted(numbers, reverse=False)[-1]  # Noncompliant {{Use "max()" instead of sorting to find this value.}}
+
+# key parameter does not suppress the issue
+shortest = sorted(words, key=len)[0]  # Noncompliant {{Use "min()" instead of sorting to find this value.}}
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+longest_by_len = sorted(words, key=len, reverse=True)[0]  # Noncompliant {{Use "max()" instead of sorting to find this value.}}
+
+# inline collection literal
+inline_min = sorted([5, 3, 8, 1])[0]  # Noncompliant
+
+# used in a boolean expression
+def get_min(data):
+    if sorted(data)[0] < 0:  # Noncompliant
+        return True
+
+
+# Compliant cases
+
+# use min() and max() directly
+min_val = min(numbers)
+max_val = max(numbers)
+min_by_len = min(words, key=len)
+max_by_len = max(words, key=len)
+
+# sorted() without indexing
+sorted_numbers = sorted(numbers)
+
+# index other than 0 or -1
+second = sorted(numbers)[1]
+second_to_last = sorted(numbers)[-2]
+
+# slice, not a single index
+first_three = sorted(numbers)[0:3]
+
+# indexing a non-sorted() object
+first = numbers[0]
+last = numbers[-1]
+
+# sorted result stored in a variable first
+ordered = sorted(numbers)
+first_ordered = ordered[0]
+last_ordered = ordered[-1]
+
+# custom (shadowed) sorted function
+def case_custom_sorted():
+    def sorted(iterable):
+        return list(iterable)
+    result = sorted(numbers)[0]
+
+# indirect call through a variable
+def case_indirect():
+    sort_fn = sorted
+    result = sort_fn(numbers)[0] # Noncompliant
+#            ^^^^^^^^^^^^^^^^^^^
+
+# sorted result wrapped in another call
+def identity(x):
+    return x
+
+wrapped = identity(sorted(numbers))[0]
+
+# multiple subscripts (tuple index) - not a single subscript
+multi_subscript = sorted(numbers)[0, 1]
+
+# qualified name callee - TypeMatchers resolves builtins.sorted correctly
+import builtins
+qualified_sorted = builtins.sorted(numbers)[0]  # Noncompliant {{Use "min()" instead of sorting to find this value.}}
+
+# unary plus index - not UNARY_MINUS, so not -1
+unary_plus_index = sorted(numbers)[+1]
+
+# unary minus applied to a variable - not a NumericLiteral operand
+neg_var = 1
+unary_minus_var_index = sorted(numbers)[-neg_var]
+
+# reverse argument is a truthy integer literal
+reverse_int_literal = sorted(numbers, reverse=1)[0]  # Noncompliant {{Use "max()" instead of sorting to find this value.}}
+
+# reverse argument is a falsy integer literal
+reverse_zero = sorted(numbers, reverse=0)[0]  # Noncompliant {{Use "min()" instead of sorting to find this value.}}
+
+# reverse argument is a variable assigned to True - resolved through single assignment
+rev_flag = True
+reverse_var = sorted(numbers, reverse=rev_flag)[0]  # Noncompliant {{Use "max()" instead of sorting to find this value.}}
+
+# reverse argument is an unknown variable - cannot determine truthiness, skip
+def some_function(flag):
+    unknown_reverse = sorted(numbers, reverse=flag)[0]
+
+# sorted used inside a lambda expression (the sorted()[index] is still flagged)
+get_last = lambda lst: sorted(lst, key=lambda m: m)[-1]  # Noncompliant {{Use "max()" instead of sorting to find this value.}}
+
+# sorted result used as subscript key into another collection
+d = {"a": 1, "b": 2, "c": 3}
+value = d[sorted(d.keys())[-1]]  # Noncompliant {{Use "max()" instead of sorting to find this value.}}
+
+# negated key lambda - sorted(key=lambda x: -f(x))[0] is still noncompliant
+items = ["hi", "hello", "hey"]
+negated_key = sorted(items, key=lambda s: -len(s))[0]  # Noncompliant {{Use "min()" instead of sorting to find this value.}}
+
+# multi-line sorted call - same rule applies regardless of formatting
+multi_line_min = sorted(  # Noncompliant {{Use "min()" instead of sorting to find this value.}}
+    words,
+    key=len,
+)[0]
+
+test_float = sorted(items)[0.5] 
diff --git a/python-checks/src/test/resources/checks/startsWithEndsWithTupleCheck.py b/python-checks/src/test/resources/checks/startsWithEndsWithTupleCheck.py
new file mode 100644
index 0000000000..1094513aec
--- /dev/null
+++ b/python-checks/src/test/resources/checks/startsWithEndsWithTupleCheck.py
@@ -0,0 +1,133 @@
+def noncompliant_chained_startswith():
+    s = "https://example.com"
+    if s.startswith("http://") or s.startswith("https://"):  # Noncompliant {{Replace chained "startswith" calls with a single call using a tuple argument.}}
+#      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        pass
+
+
+def noncompliant_chained_startswith_parenthesized_subgroup():
+    s = "https://example.com"
+    if (s.startswith("http://") or s.startswith("https://")) or s.startswith("ftp://"):  # Noncompliant {{Replace chained "startswith" calls with a single call using a tuple argument.}}
+#      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        pass
+
+
+def noncompliant_chained_endswith():
+    filename = "report.pdf"
+    if filename.endswith(".pdf") or filename.endswith(".doc"):  # Noncompliant {{Replace chained "endswith" calls with a single call using a tuple argument.}}
+#      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        pass
+
+
+class MyClass:
+    def noncompliant_attribute_receiver(self):
+        if self.name.startswith("a") or self.name.startswith("b"):  # Noncompliant {{Replace chained "startswith" calls with a single call using a tuple argument.}}
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+            pass
+
+
+def compliant_different_receivers():
+    a = "hello"
+    b = "world"
+    if a.startswith("he") or b.startswith("wo"):
+        pass
+
+
+def compliant_mixed_methods():
+    filename = "photo.jpg"
+    if filename.startswith("photo") or filename.endswith(".jpg"):
+        pass
+
+
+def compliant_mixed_startswith_endswith_three_calls():
+    s = "example.txt"
+    if s.startswith("ex") or s.endswith(".txt") or s.startswith("test"):
+        pass
+
+
+def compliant_operand_not_chainable():
+    s = "https://example.com"
+    if s.lower() or s.startswith("https://"):
+        pass
+
+    if s.startswith("http://") or s.upper():
+        pass
+
+
+def compliant_dynamic_argument():
+    prefix = "http"
+    s = "https://example.com"
+    if s.startswith(prefix) or s.startswith("https://"):
+        pass
+
+
+def compliant_negated_calls():
+    filename = "report.pdf"
+    if not filename.endswith(".tmp") or not filename.endswith(".bak"):
+        pass
+
+
+def compliant_different_function_call_receivers():
+    def get_value():
+        return "https://example.com"
+    def get_other():
+        return "ftp://example.com"
+    if get_value().startswith("http://") or get_other().startswith("https://"):
+        pass
+
+
+def compliant_extra_argument():
+    s = "https://example.com"
+    if s.startswith("http://") or s.startswith("https://", 0):
+        pass
+
+
+def compliant_no_argument():
+    s = "https://example.com"
+    if s.startswith() or s.startswith("https://"):
+        pass
+
+
+def compliant_function_call_receiver():
+    def get_url():
+        return "https://example.com"
+    if get_url().startswith("http://") or get_url().startswith("https://"):
+        pass
+
+
+def compliant_nested_call_in_receiver():
+    class Obj:
+        def inner(self):
+            return "https://example.com"
+    def outer():
+        return Obj()
+    if outer().inner().startswith("http://") or outer().inner().startswith("https://"):
+        pass
+
+
+def compliant_unpacked_argument():
+    prefixes = ("http://",)
+    s = "https://example.com"
+    if s.startswith(*prefixes) or s.startswith("https://"):
+        pass
+
+
+def compliant_unqualified_call_operand():
+    s = "https://example.com"
+    if startswith("http://") or startswith("https://"):
+        pass
+
+
+def compliant_keyword_argument():
+    s = "https://example.com"
+    if s.startswith("http://") or s.startswith(prefix="https://"):
+        pass
+
+
+def compliant_custom_startswith_on_non_string_type():
+    class MyMatcher:
+        def startswith(self, prefix):
+            return False
+    m = MyMatcher()
+    if m.startswith("foo") or m.startswith("bar"):
+        pass
diff --git a/python-checks/src/test/resources/checks/stopIterationInGenerator.py b/python-checks/src/test/resources/checks/stopIterationInGenerator.py
new file mode 100644
index 0000000000..09a886460c
--- /dev/null
+++ b/python-checks/src/test/resources/checks/stopIterationInGenerator.py
@@ -0,0 +1,203 @@
+def generator_basic():
+    yield 1
+    yield 2
+    raise StopIteration  # Noncompliant {{Replace this "raise StopIteration" with a "return" statement.}}
+
+def generator_with_int_arg():
+    yield 1
+    raise StopIteration(42)  # Noncompliant {{Replace this "raise StopIteration" with a "return" statement.}}
+
+def generator_with_str_arg():
+    yield 1
+    raise StopIteration("message")  # Noncompliant {{Replace this "raise StopIteration" with a "return" statement.}}
+
+def generator_raise_in_if(condition):
+    yield 1
+    if condition:
+        raise StopIteration  # Noncompliant
+
+def generator_raise_in_else(condition):
+    yield 1
+    if condition:
+        pass
+    else:
+        raise StopIteration  # Noncompliant
+
+def generator_raise_in_for(items):
+    for item in items:
+        if item is None:
+            raise StopIteration  # Noncompliant
+        yield item
+
+def generator_raise_in_while():
+    count = 0
+    while count < 10:
+        if count == 5:
+            raise StopIteration  # Noncompliant
+        yield count
+        count += 1
+
+def generator_raise_in_try():
+    yield 1
+    try:
+        raise StopIteration  # Noncompliant
+    except ValueError:
+        pass
+
+def generator_raise_in_except():
+    yield 1
+    try:
+        pass
+    except StopIteration:
+        raise StopIteration  # Noncompliant
+
+def generator_raise_in_finally():
+    yield 1
+    try:
+        pass
+    finally:
+        raise StopIteration  # Noncompliant
+
+def generator_raise_chained():
+    yield 1
+    raise StopIteration from ValueError("cause")  # Noncompliant
+
+async def async_generator_raise():
+    yield 1
+    raise StopIteration  # Noncompliant
+
+def generator_after_yield_from():
+    yield from range(3)
+    raise StopIteration  # Noncompliant
+
+def generator_nested_control_flow(data):
+    for item in data:
+        yield item
+        if item > 100:
+            if item > 1000:
+                raise StopIteration  # Noncompliant
+
+
+def generator_return():
+    yield 1
+    yield 2
+    return
+
+def generator_return_value():
+    yield 1
+    return 42
+
+def generator_natural_exhaustion():
+    yield 1
+    yield 2
+
+def regular_function():
+    raise StopIteration
+
+class ManualIterator:
+    def __init__(self):
+        self.count = 0
+
+    def __next__(self):
+        self.count += 1
+        if self.count > 3:
+            raise StopIteration
+        return self.count
+
+def helper_raises():
+    raise StopIteration
+
+def generator_calls_helper():
+    yield 1
+    helper_raises()
+
+def outer_generator_nested_helper():
+    def inner_helper():
+        raise StopIteration
+    yield 1
+    inner_helper()
+
+def generator_catches_stop_iteration():
+    yield 1
+    try:
+        pass
+    except StopIteration:
+        return
+
+def generator_raises_value_error():
+    yield 1
+    raise ValueError("not a stop iteration")
+
+def generator_bare_raise():
+    yield 1
+    try:
+        pass
+    except Exception:
+        raise
+
+raise StopIteration
+
+def generator_deeply_nested_helper():
+    def inner_non_generator():
+        def innermost():
+            raise StopIteration
+        innermost()
+    yield 1
+    inner_non_generator()
+
+async def async_generator_catches():
+    yield 1
+    try:
+        pass
+    except StopIteration:
+        return
+
+
+class IteratorClass:
+    def generator_method(self):
+        yield 1
+        raise StopIteration  # Noncompliant
+
+
+def nested_generators():
+    def inner_generator():
+        yield 10
+        raise StopIteration  # Noncompliant
+    yield 1
+    raise StopIteration  # Noncompliant
+
+
+class CustomStopIteration(StopIteration):
+    pass
+
+def generator_raises_stop_iteration_subclass():
+    yield 1
+    raise CustomStopIteration
+
+
+def generator_raises_stop_iteration_subclass_instance():
+    yield 1
+    raise CustomStopIteration("done")
+
+
+def generator_raise_assigned_variable():
+    yield 1
+    exc = StopIteration("error")
+    raise exc  # Noncompliant
+
+
+async def async_generator_yield_from():
+    yield from range(3)
+    raise StopIteration  # Noncompliant
+
+
+def generator_yield_in_nested_loop(items, stop_early):
+    # Real-world pattern: yield inside nested for loop, raise StopIteration in elif branch
+    for item in items:
+        if isinstance(item, list):
+            for x in item:
+                yield x
+        elif stop_early:
+            raise StopIteration  # Noncompliant
+        else:
+            yield item
diff --git a/python-checks/src/test/resources/checks/stringFormatCorrectness.py b/python-checks/src/test/resources/checks/stringFormatCorrectness.py
index c88ac4ece8..c8d2bc9ce6 100644
--- a/python-checks/src/test/resources/checks/stringFormatCorrectness.py
+++ b/python-checks/src/test/resources/checks/stringFormatCorrectness.py
@@ -119,3 +119,85 @@ def edge_case():
     no_such_function('hello')
     l4 = no_such_function('')
     l4.error("Foo %s", "Bar", "too many")
+
+
+import marimo as mo
+
+def marimo_sql():
+    mo.sql(f"SELECT * FROM table")
+    mo.sql(
+        f"""
+        SELECT plugin_rule_key, COUNT(*) as cnt
+        FROM issues
+        GROUP BY plugin_rule_key
+        """
+    )
+    engine = None
+    mo.sql(
+        f"""
+        SELECT id, name
+        FROM users
+        WHERE active = 1
+        """,
+        engine=engine
+    )
+
+
+import marimo
+
+app = marimo.App()
+
+
+@app.cell
+def _():
+    import marimo as mo
+
+    engine = None
+    return engine, mo
+
+
+# Previously flagged FP: marimo injects `mo` into a later cell parameter.
+@app.cell
+def _(engine, mo):
+    mo.sql(
+        f"""
+        SELECT id
+        FROM users
+        """,
+        engine=engine
+    )
+
+
+@app.cell
+def _(engine, mo):
+    mo.query(
+        f"SELECT id FROM users"  # Noncompliant {{Add replacement fields or use a normal string instead of an f-string.}}
+    )
+
+
+@app.cell
+def _(engine, session):
+    session.sql(
+        f"SELECT id FROM users"  # Noncompliant {{Add replacement fields or use a normal string instead of an f-string.}}
+    )
+
+
+def not_marimo_cell(engine, mo):
+    mo.sql(
+        f"SELECT id FROM users"  # Noncompliant {{Add replacement fields or use a normal string instead of an f-string.}}
+    )
+
+
+@app.cell
+def _(engine, mo):
+    alias = mo
+    alias.sql(
+        f"SELECT id FROM users"  # Noncompliant {{Add replacement fields or use a normal string instead of an f-string.}}
+    )
+
+
+@app.cell
+def _(engine, mo):
+    sql(
+        f"SELECT id FROM users"  # Noncompliant {{Add replacement fields or use a normal string instead of an f-string.}}
+    )
diff --git a/python-checks/src/test/resources/checks/sumListConcatenation.py b/python-checks/src/test/resources/checks/sumListConcatenation.py
new file mode 100644
index 0000000000..b5d9bff4c9
--- /dev/null
+++ b/python-checks/src/test/resources/checks/sumListConcatenation.py
@@ -0,0 +1,44 @@
+list_of_lists = [[1, 2], [3, 4]]
+
+
+def noncompliant_empty_list_as_start():
+    sum(list_of_lists, [])  # Noncompliant {{Use "itertools.chain.from_iterable()" instead of "sum()" to flatten or concatenate lists.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^
+
+
+def noncompliant_start_keyword_argument():
+    sum(list_of_lists, start=[])  # Noncompliant {{Use "itertools.chain.from_iterable()" instead of "sum()" to flatten or concatenate lists.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+
+def compliant_callee_is_not_builtin_sum(other_sum):
+    def sum(iterable, start):
+        result = start
+        for item in iterable:
+            result = result + item
+        return result
+
+    sum([[1, 2]], [])
+    other_sum([[1, 2]], [])
+
+
+def compliant_no_start_argument():
+    sum([1, 2, 3])
+    sum()
+
+
+def compliant_start_not_empty_list_literal():
+    sum(list_of_lists, [0])
+
+
+def compliant_start_not_list_literal():
+    sum(list_of_lists, 10)
+
+
+def fn_start_not_syntactic_empty_list():  # FN: only literal []; Name, list(), **kwargs, starred unpack
+    empty = []
+    sum(list_of_lists, empty)
+    sum(list_of_lists, list())
+    kwargs = {"start": []}
+    sum(list_of_lists, **kwargs)
+    sum(list_of_lists, *[[]])
diff --git a/python-checks/src/test/resources/checks/tempFileCreationCheck.py b/python-checks/src/test/resources/checks/tempFileCreationCheck.py
index 9ec9707489..8e18fdf6c5 100644
--- a/python-checks/src/test/resources/checks/tempFileCreationCheck.py
+++ b/python-checks/src/test/resources/checks/tempFileCreationCheck.py
@@ -1,18 +1,25 @@
 import tempfile
 import os
+from os import tempnam
+from os import tmpnam
 
 filename = os.tempnam() # Noncompliant {{'os.tempnam' is insecure. Use 'tempfile.TemporaryFile' instead}}
-#          ^^^^^^^^^^^^
+#          ^^^^^^^^^^
 tmp_file = open(filename, "w+b")
 
 filename = os.tmpnam() # Noncompliant {{'os.tmpnam' is insecure. Use 'tempfile.TemporaryFile' instead}}
-#          ^^^^^^^^^^^
+#          ^^^^^^^^^
 tmp_file = open(filename, "w+b")
 
 filename = tempfile.mktemp() # Noncompliant {{'tempfile.mktemp' is insecure. Use 'tempfile.TemporaryFile' instead}}
-#          ^^^^^^^^^^^^^^^^^
+#          ^^^^^^^^^^^^^^^
 
 tmp_file = open(filename, "w+b")
 
+filename = tempnam() # Noncompliant {{'os.tempnam' is insecure. Use 'tempfile.TemporaryFile' instead}}
+#          ^^^^^^^
+
+filename = tmpnam() # Noncompliant {{'os.tmpnam' is insecure. Use 'tempfile.TemporaryFile' instead}}
+#          ^^^^^^
 
 tmp_file = tempfile.TemporaryFile() # Compliant
diff --git a/python-checks/src/test/resources/checks/tests/assertionInTry.py b/python-checks/src/test/resources/checks/tests/assertionInTry.py
new file mode 100644
index 0000000000..3168d52978
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/assertionInTry.py
@@ -0,0 +1,249 @@
+import unittest
+import builtins
+
+import pytest
+from assertpy import assert_that
+
+
+def do_something():
+    raise AssertionError("Something went wrong")
+
+
+def get_result():
+    return "actual"
+
+
+def test_pytest_assert_in_try():
+    try:
+        do_something()
+        assert False, "Expected an AssertionError!"  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except AssertionError:
+        pass
+
+
+def test_pytest_assert_with_exception_binding():
+    try:
+        do_something()
+        assert False  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except AssertionError as e:
+        pass
+
+
+def test_pytest_assert_except_exception():
+    try:
+        assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except Exception:
+        pass
+
+
+def test_pytest_assert_except_base_exception():
+    try:
+        assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except BaseException:
+        pass
+
+
+def test_pytest_assert_bare_except():
+    try:
+        assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except:
+        pass
+
+
+class MyTest(unittest.TestCase):
+    def test_unittest_assert_equal(self):
+        try:
+            self.assertEqual(1, 2)  # Noncompliant {{Don't use assertEqual inside a try-except that catches AssertionError.}}
+        except AssertionError:
+            pass
+
+    def test_unittest_assert_true(self):
+        try:
+            self.assertTrue(False)  # Noncompliant {{Don't use assertTrue inside a try-except that catches AssertionError.}}
+        except AssertionError as e:
+            pass
+
+
+def test_assertpy():
+    try:
+        result = get_result()
+        assert_that(result).is_equal_to("expected")  # Noncompliant {{Don't use is_equal_to inside a try-except that catches AssertionError.}}
+    except AssertionError:
+        pass
+
+
+def test_assert_in_nested_block():
+    try:
+        if True:
+            assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except AssertionError:
+        pass
+
+
+def test_nested_try_outer_swallows():
+    try:
+        try:
+            assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+        except ValueError:
+            pass
+    except AssertionError:
+        pass
+
+
+def test_tuple_except():
+    try:
+        assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except (ValueError, AssertionError):
+        pass
+
+
+def test_multiple_except_clauses():
+    try:
+        assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except ValueError:
+        pass
+    except AssertionError:
+        pass
+
+
+def test_multiple_except_clauses_exception():
+    try:
+        assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except ValueError:
+        pass
+    except Exception:
+        pass
+
+
+def test_assert_that_only():
+    try:
+        assert_that(get_result())  # Noncompliant {{Don't use assert_that inside a try-except that catches AssertionError.}}
+    except AssertionError:
+        pass
+
+
+def test_assertpy_described_as_chain():
+    try:
+        assert_that(get_result()).described_as("msg").is_equal_to("expected")  # Noncompliant {{Don't use is_equal_to inside a try-except that catches AssertionError.}}
+    except AssertionError:
+        pass
+
+
+def test_multiple_assertions():
+    try:
+        assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+        assert 3 == 4  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except AssertionError:
+        pass
+
+
+def test_inner_reraise_outer_swallows():
+    try:
+        try:
+            assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+        except AssertionError:
+            raise
+    except AssertionError:
+        pass
+
+
+def test_assert_in_for_loop():
+    try:
+        for _ in range(1):
+            assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except AssertionError:
+        pass
+
+
+def test_qualified_assertion_error_except():
+    try:
+        assert 1 == 2  # Noncompliant {{Don't use assert inside a try-except that catches AssertionError.}}
+    except builtins.AssertionError:
+        pass
+
+
+def test_compliant_pytest_raises():
+    with pytest.raises(AssertionError):
+        do_something()
+
+
+def test_compliant_assert_outside_try():
+    result = get_result()
+    assert_that(result).is_equal_to("actual")
+
+
+def test_compliant_except_value_error_only():
+    try:
+        assert 1 == 2
+    except ValueError:
+        pass
+
+
+def test_compliant_reraise():
+    try:
+        assert 1 == 2
+    except AssertionError:
+        raise
+
+
+def test_compliant_reraise_with_binding():
+    try:
+        assert 1 == 2
+    except AssertionError as error:
+        raise error
+
+
+def test_compliant_assert_in_except_block():
+    try:
+        do_something()
+    except AssertionError:
+        assert True
+
+
+def test_compliant_non_assert_call_in_try():
+    try:
+        get_result()
+    except AssertionError:
+        pass
+
+
+def test_compliant_assert_after_try():
+    try:
+        do_something()
+    except AssertionError:
+        pass
+    assert True
+
+
+def test_compliant_multiple_except_only_value_error_swallows():
+    try:
+        raise ValueError()
+    except ValueError:
+        pass
+    except AssertionError:
+        pass
+
+
+def test_compliant_star_except():
+    try:
+        assert 1 == 2
+    except* AssertionError:
+        pass
+
+
+def test_compliant_inner_try_in_except_handler():
+    try:
+        pass
+    except AssertionError:
+        try:
+            assert 1 == 2
+        except ValueError:
+            pass
+
+
+class MyOtherTest(unittest.TestCase):
+    def test_compliant_non_self_assert_call(self):
+        try:
+            unittest.TestCase.assertEqual(self, 1, 2)
+        except AssertionError:
+            pass
diff --git a/python-checks/src/test/resources/checks/tests/conftest.py b/python-checks/src/test/resources/checks/tests/conftest.py
new file mode 100644
index 0000000000..a9cdb777d7
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/conftest.py
@@ -0,0 +1,21 @@
+import pytest
+
+
+@pytest.fixture
+def database():
+    return object()
+
+
+@pytest.fixture
+def combined(request):
+    return request.getfixturevalue('database')
+
+
+def pytest_configure(config):
+    request = config
+    request.getfixturevalue('database')
+
+
+def test_in_conftest_should_be_ignored(request):
+    # Tests in conftest.py are not collected; still exercise the conftest exclusion path.
+    request.getfixturevalue('database')
diff --git a/python-checks/src/test/resources/checks/tests/conftestLikeFilenames/conftest_utils.py b/python-checks/src/test/resources/checks/tests/conftestLikeFilenames/conftest_utils.py
new file mode 100644
index 0000000000..5488f730f6
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/conftestLikeFilenames/conftest_utils.py
@@ -0,0 +1 @@
+pytest_plugins = ["pytest_cov"]  # Noncompliant {{"pytest_plugins" should be defined in conftest.py files}}
diff --git a/python-checks/src/test/resources/checks/tests/conftestPlugins/conftest.py b/python-checks/src/test/resources/checks/tests/conftestPlugins/conftest.py
new file mode 100644
index 0000000000..8daba56546
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/conftestPlugins/conftest.py
@@ -0,0 +1 @@
+pytest_plugins = ["pytest_cov", "pytest_timeout"]
diff --git a/python-checks/src/test/resources/checks/tests/conftest_pytestParameterDefaultValue.py b/python-checks/src/test/resources/checks/tests/conftest_pytestParameterDefaultValue.py
new file mode 100644
index 0000000000..6c6f2222bb
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/conftest_pytestParameterDefaultValue.py
@@ -0,0 +1,37 @@
+import pytest
+from pytest import fixture
+
+
+@pytest.fixture
+def dep():
+    return 0
+
+
+# Fixtures are flagged even in conftest.py (not a test_*.py / *_test.py file name)
+@pytest.fixture
+def fixture_with_default(dep=1):  # Noncompliant {{Remove this default value so pytest can inject the parameter.}}
+#                            ^
+    return dep
+
+
+@fixture
+def imported_fixture_with_default(dep=1):  # Noncompliant
+#                                     ^
+    return dep
+
+
+@pytest.fixture
+def fixture_ok(dep):
+    return dep
+
+
+# Compliant: optional param with no matching fixture
+@pytest.fixture
+def fixture_optional_loader(loader=None):
+    return loader
+
+
+# Module-level test_* in conftest is not a pytest-collected test file pattern for our util,
+# so this should not be flagged (conftest.py is not test_*.py / *_test.py)
+def test_not_collected_in_conftest(value=1):
+    assert value > 0
diff --git a/python-checks/src/test/resources/checks/tests/dedicatedExceptionAssertion.py b/python-checks/src/test/resources/checks/tests/dedicatedExceptionAssertion.py
new file mode 100644
index 0000000000..428ec03204
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/dedicatedExceptionAssertion.py
@@ -0,0 +1,195 @@
+import unittest
+
+import pytest
+from pytest import fail as imported_fail
+
+def explode():
+    raise ValueError()
+
+def test_pytest_reproducer():
+    try:  # Noncompliant {{Replace this try/except block with a "pytest.raises" context manager.}}
+#   ^[el=+6;ec=42]
+        explode()
+    except ValueError:
+        pass
+    else:
+        pytest.fail("ValueError expected")
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Replace this fail call with a dedicated exception assertion.}}
+
+def test_pytest_else_fail():
+    try:  # Noncompliant {{Replace this try/except block with a "pytest.raises" context manager.}}
+#   ^[el=+6;ec=42]
+        explode()
+    except ValueError:
+        pass
+    else:
+        pytest.fail("ValueError expected")
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Replace this fail call with a dedicated exception assertion.}}
+
+def test_pytest_try_fail():
+    try:  # Noncompliant {{Replace this try/except block with a "pytest.raises" context manager.}}
+#   ^[el=+6;ec=12]
+        explode()
+        pytest.fail("ValueError expected")
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Replace this fail call with a dedicated exception assertion.}}
+    except ValueError:
+        pass
+
+def test_pytest_imported_fail():
+    try:  # Noncompliant {{Replace this try/except block with a "pytest.raises" context manager.}}
+#   ^[el=+6;ec=44]
+        explode()
+    except ValueError:
+        pass
+    else:
+        imported_fail("ValueError expected")
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Replace this fail call with a dedicated exception assertion.}}
+
+def test_except_body_with_extra_logic():
+    try:  # Noncompliant
+#   ^[el=+6;ec=42]
+        explode()
+    except ValueError as err:
+        print(err)
+    else:
+        pytest.fail("ValueError expected")
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Replace this fail call with a dedicated exception assertion.}}
+
+def test_no_issue_on_non_pytest_fail():
+    try:
+        explode()
+    except ValueError:
+        pass
+    else:
+        fail("ValueError expected")
+
+def test_no_issue_with_finally():
+    try:
+        explode()
+    except ValueError:
+        pass
+    else:
+        pytest.fail("ValueError expected")
+    finally:
+        cleanup()
+
+def test_no_issue_with_bare_except():
+    try:
+        explode()
+    except:
+        pytest.fail("ValueError expected")
+
+def test_no_issue_with_except_star():
+    try:
+        explode()
+    except* ValueError:
+        pytest.fail("ValueError expected")
+
+def test_no_issue_with_multi_statement_else():
+    try:
+        explode()
+    except ValueError:
+        pass
+    else:
+        message = "ValueError expected"
+        pytest.fail(message)
+
+def test_no_issue_with_multi_expression_else():
+    try:
+        explode()
+    except ValueError:
+        pass
+    else:
+        print("before fail"), pytest.fail("ValueError expected")
+
+def test_no_issue_with_non_call_expression_else():
+    try:
+        explode()
+    except ValueError:
+        pass
+    else:
+        "ValueError expected"
+
+def test_fail_in_except():
+    try:  # Noncompliant {{Remove this try/except block and let the test fail naturally if an exception is raised.}}
+#   ^[el=+4;ec=33]
+        explode()
+    except ValueError:
+        pytest.fail("unexpected")
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^< {{Remove this fail call and let the test fail naturally if an exception is raised.}}
+
+def test_no_issue_with_multi_statement_except_body():
+    try:
+        explode()
+    except ValueError:
+        message = "unexpected"
+        pytest.fail(message)
+
+def test_try_fail_with_multiple_except_clauses():
+    try:  # Noncompliant {{Replace this try/except block with a "pytest.raises" context manager.}}
+#   ^[el=+8;ec=37]
+        explode()
+        pytest.fail("ValueError expected")
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Replace this fail call with a dedicated exception assertion.}}
+    except ValueError:
+        pass
+    except TypeError as err:
+        assert "bad type" in str(err)
+
+class SomeTest(unittest.TestCase):
+    def __init__(self):
+        self.user_service = None
+        self.valid_user = None
+        self.invalid_user = None
+
+    def test_unittest_else_fail(self):
+        try:  # Noncompliant {{Replace this try/except block with "self.assertRaises()".}}
+#       ^[el=+6;ec=44]
+            explode()
+        except ValueError:
+            pass
+        else:
+            self.fail("ValueError expected")
+#           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Replace this fail call with a dedicated exception assertion.}}
+
+    def test_unittest_try_fail(self):
+        try:  # Noncompliant {{Replace this try/except block with "self.assertRaises()".}}
+#       ^[el=+6;ec=16]
+            explode()
+            self.fail("ValueError expected")
+#           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Replace this fail call with a dedicated exception assertion.}}
+        except ValueError:
+            pass
+
+    def test_no_exception_expected(self):
+        try:  # Noncompliant {{Remove this try/except block and let the test fail naturally if an exception is raised.}}
+#       ^[el=+4;ec=61]
+            self.user_service.register_user(self.valid_user)
+        except ValidationError:
+            self.fail("Should not have thrown any exception")
+#           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Remove this fail call and let the test fail naturally if an exception is raised.}}
+
+    def test_exception_details(self):
+        try:  # Noncompliant {{Replace this try/except block with "self.assertRaises()".}}
+#       ^[el=+6;ec=53]
+            self.user_service.register_user(self.invalid_user)
+            self.fail("Expected ValidationError to be thrown")
+#           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Replace this fail call with a dedicated exception assertion.}}
+        except ValidationError as e:
+            self.assertEqual("Invalid email", str(e))
+
+    def test_multiple_except_clauses(self):
+        try:
+            self.user_service.register_user(self.valid_user)
+        except ValidationError:
+            self.fail("got ValidationError")
+        except TypeError:
+            self.assertEqual("bad type", "bad type")
+
+    def test_no_issue_outside_unittest(self):
+        try:
+            explode()
+        except ValueError:
+            pass
+        else:
+            other.fail("ValueError expected")
diff --git a/python-checks/src/test/resources/checks/tests/deprecatedYieldFixture.py b/python-checks/src/test/resources/checks/tests/deprecatedYieldFixture.py
new file mode 100644
index 0000000000..e3d0d13a29
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/deprecatedYieldFixture.py
@@ -0,0 +1,100 @@
+import pytest
+
+
+@pytest.yield_fixture  # Noncompliant {{Replace deprecated pytest.yield_fixture with pytest.fixture.}}
+#^^^^^^^^^^^^^^^^^^^^
+def bare_yield_fixture():
+    value = acquire()
+    yield value
+    release(value)
+
+
+@pytest.yield_fixture()  # Noncompliant {{Replace deprecated pytest.yield_fixture with pytest.fixture.}}
+#^^^^^^^^^^^^^^^^^^^^^^
+def called_yield_fixture():
+    value = acquire()
+    yield value
+    release(value)
+
+
+@pytest.yield_fixture(scope="module")  # Noncompliant {{Replace deprecated pytest.yield_fixture with pytest.fixture.}}
+#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+def yield_fixture_with_kwargs():
+    value = acquire()
+    yield value
+    release(value)
+
+
+from pytest import yield_fixture
+
+
+@yield_fixture  # Noncompliant {{Replace deprecated pytest.yield_fixture with pytest.fixture.}}
+#^^^^^^^^^^^^^
+def imported_yield_fixture():
+    value = acquire()
+    yield value
+    release(value)
+
+
+from pytest import yield_fixture as legacy_fixture
+
+
+@legacy_fixture  # Noncompliant {{Replace deprecated pytest.yield_fixture with pytest.fixture.}}
+#^^^^^^^^^^^^^^
+def aliased_imported_yield_fixture():
+    value = acquire()
+    yield value
+    release(value)
+
+
+import pytest as pt
+
+
+@pt.yield_fixture  # Noncompliant {{Replace deprecated pytest.yield_fixture with pytest.fixture.}}
+#^^^^^^^^^^^^^^^^
+def aliased_module_yield_fixture():
+    value = acquire()
+    yield value
+    release(value)
+
+
+@pytest.fixture
+def compliant_fixture():
+    value = acquire()
+    yield value
+    release(value)
+
+
+@pytest.fixture()
+def compliant_called_fixture():
+    value = acquire()
+    yield value
+    release(value)
+
+
+@pytest.fixture(scope="module")
+def compliant_fixture_with_kwargs():
+    value = acquire()
+    yield value
+    release(value)
+
+
+class NotPytest:
+    @staticmethod
+    def yield_fixture(*args, **kwargs):
+        pass
+
+
+@NotPytest.yield_fixture
+def decoy_class_attribute():
+    pass
+
+
+@bob.bob
+def decoy_qualified_expression_null_symbol():
+    pass
+
+
+@"my string"
+def decoy_decorator_without_symbol():
+    pass
diff --git a/python-checks/src/test/resources/checks/tests/duplicateParametrizeCases.py b/python-checks/src/test/resources/checks/tests/duplicateParametrizeCases.py
new file mode 100644
index 0000000000..b752e326dd
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/duplicateParametrizeCases.py
@@ -0,0 +1,196 @@
+import pytest
+
+
+# Duplicate int literals
+@pytest.mark.parametrize("n", [
+    1,
+    2,
+    2,  # Noncompliant {{Remove this duplicate test case.}}
+#   ^
+#   ^@-2< {{Original.}}
+    3,
+])
+def test_duplicate_ints(n):
+    return n * 2
+
+
+# Duplicate string literals
+@pytest.mark.parametrize("value", [
+    "a",
+    "b",
+    "a",  # Noncompliant {{Remove this duplicate test case.}}
+#   ^^^
+])
+def test_duplicate_strings(value):
+    assert value in ("a", "b")
+
+
+# Duplicate tuple literals
+@pytest.mark.parametrize("point", [
+    (1, 2),
+    (3, 4),
+    (1, 2),  # Noncompliant {{Remove this duplicate test case.}}
+#   ^^^^^^
+])
+def test_duplicate_tuples(point):
+    operand, expected = point
+    assert operand < expected
+
+
+# Duplicate names
+@pytest.mark.parametrize("case", [
+    FIRST,
+    SECOND,
+    FIRST,  # Noncompliant {{Remove this duplicate test case.}}
+#   ^^^^^
+])
+def test_duplicate_names(case):
+    registry.append(case)
+
+
+# Duplicate call expressions
+@pytest.mark.parametrize("case", [
+    make_case(1),
+    make_case(2),
+    make_case(1),  # Noncompliant
+])
+def test_duplicate_calls(case):
+    consume(case)
+
+
+# Three identical cases: both the second and third are flagged against the first
+@pytest.mark.parametrize("n", [
+    7,
+    7,  # Noncompliant
+    7,  # Noncompliant
+])
+def test_triple_duplicate(n):
+    counter.increment(n)
+
+
+# Two independent duplicate groups produce two separate issues
+@pytest.mark.parametrize("case", [
+    A,
+    B,
+    A,  # Noncompliant
+    B,  # Noncompliant
+])
+def test_two_duplicate_groups(case):
+    tracker.record(case)
+
+
+# Duplicate detected when argvalues is passed as a keyword argument
+@pytest.mark.parametrize("n", argvalues=[
+    8,
+    8,  # Noncompliant
+])
+def test_duplicate_via_keyword_argument(n):
+    pipeline.run(n)
+
+
+# Duplicate detected when argvalues is a tuple literal rather than a list
+@pytest.mark.parametrize("n", (
+    9,
+    9,  # Noncompliant
+))
+def test_duplicate_in_tuple_argvalues(n):
+    logger.debug(n)
+
+
+# Parenthesized list is still a list literal once parentheses are stripped
+@pytest.mark.parametrize("n", ([
+    10,
+    10,  # Noncompliant
+]))
+def test_duplicate_in_parenthesized_list(n):
+    yield n
+
+
+# Parentheses around a case must not hide equivalence with a bare literal
+@pytest.mark.parametrize("n", [
+    1,
+    (1),  # Noncompliant {{Remove this duplicate test case.}}
+#   ^^^
+#   ^@-2< {{Original.}}
+])
+def test_parenthesized_case_duplicate(n):
+    assert n == 1
+
+
+# Nested parentheses around a case
+@pytest.mark.parametrize("n", [
+    ((2)),
+    2,  # Noncompliant {{Remove this duplicate test case.}}
+#   ^
+])
+def test_nested_parenthesized_case_duplicate(n):
+    assert n == 2
+
+
+# Compliant: all cases are distinct
+@pytest.mark.parametrize("n", [1, 2, 3])
+def test_distinct_ints(n):
+    history.append(n)
+
+
+# Compliant: distinct tuples
+@pytest.mark.parametrize("operand,expected", [
+    (1, 2),
+    (2, 4),
+    (3, 6),
+])
+def test_distinct_tuples(operand, expected):
+    assert operand * 2 == expected
+
+
+# Compliant: single-element list can never contain a duplicate
+@pytest.mark.parametrize("n", [1])
+def test_single_case(n):
+    ...
+
+
+# Compliant: values that only look similar are not equivalent expressions
+@pytest.mark.parametrize("value", [1, 1.0, True])
+def test_distinct_literal_kinds(value):
+    kinds.add(type(value))
+
+
+# Compliant: non-literal argvalues (a variable) is not inspected, even if it holds duplicates
+cases_with_duplicates = [1, 2, 2, 3]
+
+
+@pytest.mark.parametrize("n", cases_with_duplicates)
+def test_non_literal_argvalues_skipped(n):
+    seen.add(n)
+
+
+# Compliant: argvalues produced by a call is not inspected
+def build_cases():
+    return [1, 2, 2, 3]
+
+
+@pytest.mark.parametrize("n", build_cases())
+def test_call_argvalues_skipped(n):
+    processed.add(n)
+
+
+# Compliant: no argvalues provided at all
+@pytest.mark.parametrize("n")
+def test_parametrize_without_values(n):
+    assert n is not None
+
+
+# Compliant: decorator that is not a call expression
+def plain_decorator(func):
+    return func
+
+
+@plain_decorator
+def test_non_call_decorator():
+    return True
+
+
+# Compliant: unrelated pytest.mark call
+@pytest.mark.skip()
+def test_unrelated_call_decorator():
+    pass
diff --git a/python-checks/src/test/resources/checks/tests/emptyModule.py b/python-checks/src/test/resources/checks/tests/emptyModule.py
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/emptyModule.py
@@ -0,0 +1 @@
+
diff --git a/python-checks/src/test/resources/checks/tests/emptyParametrizeValues.py b/python-checks/src/test/resources/checks/tests/emptyParametrizeValues.py
new file mode 100644
index 0000000000..6c9cc1c4b0
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/emptyParametrizeValues.py
@@ -0,0 +1,342 @@
+import pytest
+
+
+def double(operand):
+    return operand * 2
+
+
+@pytest.mark.parametrize('operand,expected', [])  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                            ^^
+def test_double_empty_list(operand, expected):
+    assert double(operand) == expected
+
+
+@pytest.mark.parametrize('operand,expected', ())  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                            ^^
+def test_double_empty_tuple(operand, expected):
+    assert double(operand) == expected
+
+
+@pytest.mark.parametrize('operand,expected', [
+    (1, 2),
+    (2, 4),
+])
+def test_double_populated_list(operand, expected):
+    assert double(operand) == expected
+
+
+@pytest.mark.parametrize('operand,expected', (
+    (1, 2),
+    (2, 4),
+))
+def test_double_non_empty_tuple(operand, expected):
+    assert double(operand) == expected
+
+
+empty_cases = []
+
+
+@pytest.mark.parametrize('operand', empty_cases)  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^^^^^
+def test_empty_list_variable_never_appended(operand):
+    assert double(operand) == operand * 2
+
+
+populated_before = []
+populated_before.append(1)
+populated_before.append(2)
+
+
+@pytest.mark.parametrize('operand', populated_before)
+def test_list_populated_via_append_before(operand):
+    assert double(operand) == operand * 2
+
+
+populated_after = []
+
+
+@pytest.mark.parametrize('operand', populated_after)
+def test_list_populated_via_append_after(operand):
+    assert double(operand) == operand * 2
+
+
+populated_after.append(1)
+
+
+populated_via_extend = []
+populated_via_extend.extend([(1, 2)])
+
+
+@pytest.mark.parametrize('case', populated_via_extend)
+def test_list_populated_via_extend(case):
+    assert double(case[0]) == case[1]
+
+
+populated_via_iadd = []
+populated_via_iadd += [(1, 2)]
+
+
+@pytest.mark.parametrize('case', populated_via_iadd)
+def test_list_populated_via_iadd(case):
+    assert double(case[0]) == case[1]
+
+
+populated_via_insert = []
+populated_via_insert.insert(0, (1, 2))
+
+
+@pytest.mark.parametrize('case', populated_via_insert)
+def test_list_populated_via_insert(case):
+    assert double(case[0]) == case[1]
+
+
+wrong_method = []
+wrong_method.count(0)
+
+
+@pytest.mark.parametrize('operand', wrong_method)  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^^^^^^
+def test_list_with_non_populating_method_call(operand):
+    assert operand is None
+
+
+dict_cases = {}
+dict_cases.update({'a': 1})
+
+
+@pytest.mark.parametrize('case', dict_cases)
+def test_dict_populated_via_update(case):
+    assert case == 'a'
+
+
+setdefault_cases = {}
+setdefault_cases.setdefault('a', 1)
+
+
+@pytest.mark.parametrize('case', setdefault_cases)
+def test_dict_populated_via_setdefault(case):
+    assert case == 'a'
+
+
+merged_dict_cases = {}
+merged_dict_cases |= {'a': 1}
+
+
+@pytest.mark.parametrize('case', merged_dict_cases)
+def test_dict_populated_via_ior(case):
+    assert case == 'a'
+
+
+class TestOffsets:
+    offset_cases = []
+    offset_cases.append(
+        (1, 2),
+    )
+    offset_cases.append(
+        (2, 4),
+    )
+
+    @pytest.mark.parametrize("case", offset_cases)
+    def test_offset(self, case):
+        operand, expected = case
+        assert double(operand) == expected
+
+
+class TestClassCases:
+    class_cases = []
+    class_cases.append(1)
+
+    @pytest.mark.parametrize('case', class_cases)
+    def test_class_cases(self, case):
+        assert case == 1
+
+
+def plain_decorator(func):
+    return func
+
+
+@plain_decorator
+def test_non_call_decorator():
+    assert True
+
+
+@pytest.mark.skip()
+def test_unrelated_call_decorator():
+    assert True
+
+
+@pytest.mark.parametrize('operand')
+def test_parametrize_without_values(operand):
+    assert operand is not None
+
+
+@pytest.mark.parametrize('operand', argvalues=unresolved_var)
+def test_parametrize_unresolved_values(operand):
+    assert operand is not None
+
+
+@pytest.mark.parametrize('operand', argvalues=[])  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                             ^^
+def test_empty_list_keyword(operand):
+    assert double(operand) == operand * 2
+
+
+@pytest.mark.parametrize('operand', argvalues=())  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                             ^^
+def test_empty_tuple_keyword(operand):
+    assert double(operand) == operand * 2
+
+
+@pytest.mark.parametrize('operand', ([]))  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                    ^^
+def test_empty_list_parenthesized(operand):
+    assert double(operand) == operand * 2
+
+
+not_a_list = None
+
+
+@pytest.mark.parametrize('operand', not_a_list)  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^^^^
+def test_none_variable(operand):
+    assert operand is None
+
+
+aliased = []
+other = aliased
+other.append(1)
+
+
+@pytest.mark.parametrize('operand', aliased)
+def test_append_via_different_name(operand):
+    assert operand == 1
+
+
+split_alias_cases = []
+left, right = split_alias_cases
+
+
+@pytest.mark.parametrize('operand', split_alias_cases)  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^^^^^^^^^^^
+def test_unpacking_assignment_is_not_simple_alias(operand):
+    assert operand is None
+
+
+attr_alias_cases = []
+holder = type('Holder', (), {})()
+holder.cases = attr_alias_cases
+
+
+@pytest.mark.parametrize('operand', attr_alias_cases)  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^^^^^^^^^^
+def test_assignment_to_attribute_is_not_alias_population(operand):
+    assert operand is None
+
+
+nested_population = []
+
+
+def populate_nested_population():
+    nested_population.append(1)
+
+
+@pytest.mark.parametrize('operand', nested_population)  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^^^^^^^^^^^
+def test_append_only_inside_never_called_function(operand):
+    assert operand == 1
+
+
+@pytest.mark.parametrize('operand', set())  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^
+def test_empty_set_constructor(operand):
+    assert operand is None
+
+
+@pytest.mark.parametrize('operand', range(0))  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^^
+def test_empty_range_constructor(operand):
+    assert operand is None
+
+
+@pytest.mark.parametrize('operand', range(-1))  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^^^
+def test_empty_negative_range_constructor(operand):
+    assert operand is None
+
+
+@pytest.mark.parametrize('operand', range(1, 1))
+def test_two_arg_empty_range_not_detected(operand):
+    assert operand is None
+
+
+@pytest.mark.parametrize('operand', range(0.5))
+def test_float_range_argument_not_detected(operand):
+    assert operand is None
+
+
+n = 0
+
+
+@pytest.mark.parametrize('operand', range(n))
+def test_range_with_non_literal_argument(operand):
+    assert operand is None
+
+
+range_args = (0,)
+
+
+@pytest.mark.parametrize('operand', range(*range_args))
+def test_range_with_unpacked_argument(operand):
+    assert operand is None
+
+
+@pytest.mark.parametrize('operand', list())  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^
+def test_empty_list_constructor(operand):
+    assert double(operand) == operand * 2
+
+
+@pytest.mark.parametrize('operand', dict())  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^
+def test_empty_dict_constructor(operand):
+    assert operand is None
+
+
+@pytest.mark.parametrize('operand', tuple())  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^
+def test_empty_tuple_constructor(operand):
+    assert operand is None
+
+
+empty_set_var = set()
+
+
+@pytest.mark.parametrize('operand', empty_set_var)  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^^^^^^^^^^^^
+def test_empty_set_variable(operand):
+    assert operand is None
+
+
+populated_set = set()
+populated_set.add(1)
+
+
+@pytest.mark.parametrize('operand', populated_set)
+def test_set_populated_via_add(operand):
+    assert operand == 1
+
+
+@pytest.mark.parametrize('operand', [])  # Noncompliant {{Add at least one case to the parametrize values.}}
+#                                   ^^
+def test_empty_literal_despite_unrelated_append(operand):
+    assert operand is None
+
+
+cases_with_attr_access = []
+_ = cases_with_attr_access.append
+cases_with_attr_access.append(1)
+
+
+@pytest.mark.parametrize('operand', cases_with_attr_access)
+def test_append_call_and_attribute_ref(operand):
+    assert operand == 1
diff --git a/python-checks/src/test/resources/checks/tests/emptyPytestModule_test.py b/python-checks/src/test/resources/checks/tests/emptyPytestModule_test.py
new file mode 100644
index 0000000000..482d2781b9
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/emptyPytestModule_test.py
@@ -0,0 +1,7 @@
+def helper_only_module():  # Noncompliant@-1 {{Add some tests to this file.}}
+    return 42
+
+
+class TestHelperOnly:
+    def helper(self):
+        return 42
diff --git a/python-checks/src/test/resources/checks/tests/empty_groupSimilarTestsParameterized.py b/python-checks/src/test/resources/checks/tests/empty_groupSimilarTestsParameterized.py
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/empty_groupSimilarTestsParameterized.py
@@ -0,0 +1 @@
+
diff --git a/python-checks/src/test/resources/checks/tests/fixtureParamDependenciesNonPytestFile.py b/python-checks/src/test/resources/checks/tests/fixtureParamDependenciesNonPytestFile.py
new file mode 100644
index 0000000000..7f320f5f65
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/fixtureParamDependenciesNonPytestFile.py
@@ -0,0 +1,5 @@
+import pytest
+
+
+def helper(request):
+    request.getfixturevalue('database')
diff --git a/python-checks/src/test/resources/checks/tests/fixtureParamDependenciesPytestHook_test.py b/python-checks/src/test/resources/checks/tests/fixtureParamDependenciesPytestHook_test.py
new file mode 100644
index 0000000000..c5f17cb004
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/fixtureParamDependenciesPytestHook_test.py
@@ -0,0 +1,15 @@
+from pytest import fixture
+
+
+@fixture
+def combined(request):
+    return request.getfixturevalue('database')
+
+
+def pytest_runtest_setup(request):
+    request.getfixturevalue('database')
+
+
+def test_with_imported_fixture_decorator(request):
+    request.getfixturevalue('database')  # Noncompliant {{Declare this fixture as a test function parameter instead of using "request.getfixturevalue()" with a string literal.}}
+#                           ^^^^^^^^^^
diff --git a/python-checks/src/test/resources/checks/tests/fixtureParamDependencies_test.py b/python-checks/src/test/resources/checks/tests/fixtureParamDependencies_test.py
new file mode 100644
index 0000000000..b1e2220f02
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/fixtureParamDependencies_test.py
@@ -0,0 +1,93 @@
+import pytest
+
+
+@pytest.fixture
+def database():
+    class DB:
+        def query(self, sql):
+            return 1
+
+    return DB()
+
+
+@pytest.fixture
+def cache():
+    return object()
+
+
+def test_database_query(request):
+    db = request.getfixturevalue('database')  # Noncompliant {{Declare this fixture as a test function parameter instead of using "request.getfixturevalue()" with a string literal.}}
+#                                ^^^^^^^^^^
+    result = db.query('SELECT 1')
+    assert result == 1
+
+
+def test_database_query_keyword(request):
+    db = request.getfixturevalue(argname='database')  # Noncompliant {{Declare this fixture as a test function parameter instead of using "request.getfixturevalue()" with a string literal.}}
+    assert db is not None
+
+
+def test_database_query_compliant(database):
+    result = database.query('SELECT 1')
+    assert result == 1
+
+
+@pytest.fixture(scope="module")
+def combined_with_scope(request):
+    return request.getfixturevalue('database')
+
+
+@pytest.fixture
+def combined(request):
+    return request.getfixturevalue('database')
+
+
+def test_no_fixture_name_argument(request):
+    request.getfixturevalue()
+
+
+def test_other_calls(request, database):
+    database.query('SELECT 1')
+
+
+def test_other_fixture_request_method(request):
+    request.addfinalizer('cleanup')
+
+
+@pytest.mark.parametrize('fixture_name', ['database', 'cache'])
+def test_matrix(request, fixture_name):
+    fixture = request.getfixturevalue(fixture_name)
+    assert fixture is not None
+
+
+def test_dynamic_fixture_name(request):
+    name = 'database'
+    fixture = request.getfixturevalue(name)  # Noncompliant {{Declare this fixture as a test function parameter instead of using "request.getfixturevalue()" with a string literal.}}
+#                                     ^^^^
+    assert fixture is not None
+
+
+def test_interpolated_fstring(request):
+    key = "users"
+    request.getfixturevalue(f"pub_{key}")
+    request.getfixturevalue(f"sig_{key}")
+
+
+def test_useless_fstring(request):
+    request.getfixturevalue(f"database")  # Noncompliant {{Declare this fixture as a test function parameter instead of using "request.getfixturevalue()" with a string literal.}}
+#                           ^^^^^^^^^^^
+
+
+def test_format_and_percent_strings(request):
+    key = "users"
+    request.getfixturevalue("pub_{}".format(key))
+    request.getfixturevalue("pub_%s" % key)
+
+
+def helper_not_a_test(request):
+    request.getfixturevalue('database')
+
+
+class TestClass:
+    def test_in_class(self, request):
+        request.getfixturevalue('database')  # Noncompliant {{Declare this fixture as a test function parameter instead of using "request.getfixturevalue()" with a string literal.}}
diff --git a/python-checks/src/test/resources/checks/tests/groupSimilarTestsParameterized.py b/python-checks/src/test/resources/checks/tests/groupSimilarTestsParameterized.py
new file mode 100644
index 0000000000..36ccef15e0
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/groupSimilarTestsParameterized.py
@@ -0,0 +1,21 @@
+def setup_tax():
+    pass
+
+
+def get_tax(value):
+    return value
+
+
+def test_not_null1():
+    setup_tax()
+    assert get_tax(1) is not None
+
+
+def test_not_null2():
+    setup_tax()
+    assert get_tax(2) is not None
+
+
+def test_not_null3():
+    setup_tax()
+    assert get_tax(3) is not None
diff --git a/python-checks/src/test/resources/checks/tests/groupSimilarTestsParameterized_test.py b/python-checks/src/test/resources/checks/tests/groupSimilarTestsParameterized_test.py
new file mode 100644
index 0000000000..c6f7e5afee
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/groupSimilarTestsParameterized_test.py
@@ -0,0 +1,24 @@
+def setup_tax():
+    pass
+
+
+def get_tax(value):
+    return value
+
+
+def test_not_null1():  # Noncompliant {{Group these similar tests into a single parameterized test.}}
+#   ^^^^^^^^^^^^^^
+    setup_tax()
+    assert get_tax(1) is not None
+
+
+def test_not_null2():
+#   ^^^^^^^^^^^^^^< {{Similar test.}}
+    setup_tax()
+    assert get_tax(2) is not None
+
+
+def test_not_null3():
+#   ^^^^^^^^^^^^^^< {{Similar test.}}
+    setup_tax()
+    assert get_tax(3) is not None
diff --git a/python-checks/src/test/resources/checks/tests/helpersOnlyModule.py b/python-checks/src/test/resources/checks/tests/helpersOnlyModule.py
new file mode 100644
index 0000000000..25f5ee53ad
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/helpersOnlyModule.py
@@ -0,0 +1,12 @@
+import unittest
+
+
+class TestHelper:
+    def helper(self):
+        return 42
+
+
+class EmptyUnittestCase(unittest.TestCase):  # Noncompliant {{Add some tests to this class.}}
+#     ^^^^^^^^^^^^^^^^^
+    def helper(self):
+        return 42
diff --git a/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessage.py b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessage.py
new file mode 100644
index 0000000000..fbcb56b561
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessage.py
@@ -0,0 +1,127 @@
+import pytest
+from pytest import fail as imported_fail
+
+
+def test_assert_false():
+    assert False  # Noncompliant {{Replace this assertion with pytest.fail(...) and provide a message.}}
+#   ^^^^^^^^^^^^
+
+
+def test_assert_zero():
+    assert 0  # Noncompliant {{Replace this assertion with pytest.fail(...) and provide a message.}}
+#   ^^^^^^^^
+
+
+def test_assert_false_with_message():
+    assert False, "not ready yet"  # Noncompliant {{Replace this assertion with pytest.fail(...) and provide a message.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_assert_zero_parenthesized():
+    assert (0)  # Noncompliant {{Replace this assertion with pytest.fail(...) and provide a message.}}
+#   ^^^^^^^^^^
+
+
+def test_assert_equality_ok():
+    assert x == 1
+
+
+def test_assert_name_ok():
+    assert some_name
+
+
+def test_assert_true_ok():
+    assert True
+
+
+def test_assert_one_ok():
+    assert 1
+
+
+def test_assert_non_integral_float_ok():
+    # valueAsLong throws NumberFormatException for non-integral floats
+    assert 0.5
+
+
+def test_assert_zero_float():
+    assert 0.0  # Noncompliant {{Replace this assertion with pytest.fail(...) and provide a message.}}
+#   ^^^^^^^^^^
+
+
+def test_pytest_fail_no_args():
+    pytest.fail()  # Noncompliant {{Add a message explaining why this test fails.}}
+#   ^^^^^^^^^^^^^
+
+
+def test_pytest_fail_empty_message():
+    pytest.fail("")  # Noncompliant {{Add a message explaining why this test fails.}}
+#   ^^^^^^^^^^^^^^^
+
+
+def test_pytest_fail_empty_reason_keyword():
+    pytest.fail(reason="")  # Noncompliant {{Add a message explaining why this test fails.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_pytest_fail_whitespace_message():
+    pytest.fail("   ")  # Noncompliant {{Add a message explaining why this test fails.}}
+#   ^^^^^^^^^^^^^^^^^^
+
+
+def test_pytest_fail_whitespace_reason_keyword():
+    pytest.fail(reason="   ")  # Noncompliant {{Add a message explaining why this test fails.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_pytest_fail_with_message_ok():
+    pytest.fail("feature not implemented yet")
+
+
+def test_pytest_fail_with_reason_keyword_ok():
+    pytest.fail(reason="blocked on issue 42")
+
+
+def test_pytest_fail_with_legacy_msg_keyword_ok():
+    pytest.fail(msg="Sample check failed")
+
+
+def test_pytest_fail_with_legacy_msg_keyword_and_pytrace_ok():
+    pytest.fail(msg="Sample check failed", pytrace=False)
+
+
+def test_pytest_fail_with_non_string_legacy_msg_ok(message):
+    pytest.fail(msg=message)
+
+
+def test_pytest_fail_empty_legacy_msg_keyword():
+    pytest.fail(msg="")  # Noncompliant {{Add a message explaining why this test fails.}}
+#   ^^^^^^^^^^^^^^^^^^^
+
+
+def test_pytest_fail_whitespace_legacy_msg_keyword():
+    pytest.fail(msg="   ")  # Noncompliant {{Add a message explaining why this test fails.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_pytest_fail_with_non_string_reason_ok(message):
+    pytest.fail(reason=message)
+
+
+def test_pytest_fail_with_non_string_message_ok(message):
+    pytest.fail(message)
+
+
+def test_imported_fail_no_args():
+    imported_fail()  # Noncompliant {{Add a message explaining why this test fails.}}
+#   ^^^^^^^^^^^^^^^
+
+
+def test_local_fail_ok():
+    def fail():
+        pass
+    fail()
+
+
+class SomeTest:
+    def test_unittest_fail_ok(self):
+        self.fail()
diff --git a/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageFromImport.py b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageFromImport.py
new file mode 100644
index 0000000000..119a7d11fd
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageFromImport.py
@@ -0,0 +1,7 @@
+from pytest import fail as imported_fail
+
+
+def test_assert_false_with_from_import():
+    assert False  # Noncompliant {{Replace this assertion with pytest.fail(...) and provide a message.}}
+#   ^^^^^^^^^^^^
+    imported_fail("ready")
diff --git a/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageMultipleImports.py b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageMultipleImports.py
new file mode 100644
index 0000000000..5ca75e00df
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageMultipleImports.py
@@ -0,0 +1,15 @@
+import pytest
+from pytest import fail
+from pytest.mark import parametrize
+
+
+def test_assert_false_with_multiple_pytest_imports():
+    assert False  # Noncompliant {{Replace this assertion with pytest.fail(...) and provide a message.}}
+#   ^^^^^^^^^^^^
+    fail("ok")
+
+
+@parametrize("n", [1])
+def test_parametrize_import_enables_assert(n):
+    assert False  # Noncompliant {{Replace this assertion with pytest.fail(...) and provide a message.}}
+#   ^^^^^^^^^^^^
diff --git a/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageNoPytest.py b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageNoPytest.py
new file mode 100644
index 0000000000..0776e1ed2d
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageNoPytest.py
@@ -0,0 +1,30 @@
+# No pytest import: assert False / assert 0 must not be flagged
+# (cannot know whether the runner is pytest or unittest).
+
+
+def test_assert_false_without_pytest():
+    assert False
+
+
+def test_assert_zero_without_pytest():
+    assert 0
+
+
+def test_assert_false_with_message_without_pytest():
+    assert False, "not ready yet"
+
+
+class TestWithoutPytest:
+    def test_assert_false(self):
+        assert False
+
+    def test_assert_zero(self):
+        assert 0
+
+
+def fail():
+    pass
+
+
+def test_local_fail_without_pytest():
+    fail()
diff --git a/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageRelativeImport.py b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageRelativeImport.py
new file mode 100644
index 0000000000..31c5406c3b
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/intentionalTestFailureMessageRelativeImport.py
@@ -0,0 +1,5 @@
+from . import local_helper
+
+
+def test_relative_import_does_not_enable_assert():
+    assert False
diff --git a/python-checks/src/test/resources/checks/tests/misspelledMockAssertion.py b/python-checks/src/test/resources/checks/tests/misspelledMockAssertion.py
new file mode 100644
index 0000000000..6056a96f00
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/misspelledMockAssertion.py
@@ -0,0 +1,109 @@
+from unittest.mock import AsyncMock, MagicMock, Mock, patch
+
+
+def process(saver, item):
+    saver.save(item)
+
+
+def notify_user(user_id):
+    pass
+
+
+def test_assert_called_with_typo():
+    saver = Mock()
+    process(saver, "item")
+    saver.save.assert_called_wit("item")  # Noncompliant {{Correct this misspelled mock assertion; did you mean "assert_called_with"?}}
+#              ^^^^^^^^^^^^^^^^^
+
+
+def test_assert_called_once_with_typo():
+    mock = Mock()
+    mock(1)
+    mock.assert_caled_once_with(1)  # Noncompliant {{Correct this misspelled mock assertion; did you mean "assert_called_once_with"?}}
+#        ^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_assert_called_typo_on_magic_mock():
+    mock = MagicMock()
+    mock()
+    mock.assert_calld()  # Noncompliant {{Correct this misspelled mock assertion; did you mean "assert_called"?}}
+#        ^^^^^^^^^^^^
+
+
+def test_assert_not_called_typo():
+    mock = Mock()
+    mock.assert_not_calld()  # Noncompliant {{Correct this misspelled mock assertion; did you mean "assert_not_called"?}}
+#        ^^^^^^^^^^^^^^^^
+
+
+def test_assert_any_call_typo():
+    mock = Mock()
+    mock(1)
+    mock.assert_any_cal(1)  # Noncompliant {{Correct this misspelled mock assertion; did you mean "assert_any_call"?}}
+#        ^^^^^^^^^^^^^^
+
+
+def test_assert_has_calls_typo():
+    mock = Mock()
+    mock.assert_has_call([])  # Noncompliant {{Correct this misspelled mock assertion; did you mean "assert_has_calls"?}}
+#        ^^^^^^^^^^^^^^^
+
+
+def test_async_mock_await_typo():
+    mock = AsyncMock()
+    mock.assert_awaited_wit()  # Noncompliant {{Correct this misspelled mock assertion; did you mean "assert_awaited_with"?}}
+#        ^^^^^^^^^^^^^^^^^^
+
+
+def test_patch_context_manager_typo():
+    with patch("os.path.exists") as exists:
+        exists.assert_called_once_wit()  # FN - patch return type is unknown
+
+
+def test_correct_assertions_are_ok():
+    mock = Mock()
+    mock(1, 2)
+    mock.assert_called()
+    mock.assert_called_once()
+    mock.assert_called_with(1, 2)
+    mock.assert_called_once_with(1, 2)
+    mock.assert_any_call(1, 2)
+    mock.assert_has_calls([])
+    mock.assert_not_called()
+
+
+def test_async_correct_assertions_are_ok():
+    mock = AsyncMock()
+    mock.assert_awaited()
+    mock.assert_awaited_once()
+    mock.assert_awaited_with()
+    mock.assert_awaited_once_with()
+    mock.assert_any_await()
+    mock.assert_has_awaits([])
+    mock.assert_not_awaited()
+
+
+def test_unrelated_attributes_are_ok():
+    mock = Mock()
+    mock.return_value = 1
+    mock.side_effect = None
+    mock.reset_mock()
+    mock.configure_mock(foo=1)
+    # Far from any assertion name: not raised (safe).
+    mock.completely_different_name()
+    # Looks a bit like assert but too distant from known methods.
+    mock.assert_something_totally_custom()
+
+
+def test_non_mock_objects_are_ok():
+    class Helper:
+        def assert_called_wit(self, *_args):
+            pass
+
+    Helper().assert_called_wit(1)
+
+
+def test_exact_custom_member_matching_known_name_is_ok():
+    # Exact known assertion names must never be flagged.
+    mock = Mock()
+    mock.assert_called_with(1)
diff --git a/python-checks/src/test/resources/checks/tests/mockPatchLambdaReturnValue.py b/python-checks/src/test/resources/checks/tests/mockPatchLambdaReturnValue.py
new file mode 100644
index 0000000000..7f876efc73
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/mockPatchLambdaReturnValue.py
@@ -0,0 +1,266 @@
+import mock
+import unittest.mock
+from unittest.mock import patch
+
+
+class Target:
+    attribute = None
+
+
+def helper(*args, **kwargs):
+    ...
+
+
+def test_patch_positional_lambda():
+    with patch("app.api.fetch", lambda: {"ok": True}):  # Noncompliant {{Replace this lambda with a "return_value" argument.}}
+#                               ^^^^^^^^^^^^^^^^^^^^
+        helper()
+
+
+def test_patch_keyword_lambda():
+    with patch("app.api.fetch", new=lambda: 42):  # Noncompliant
+#                                   ^^^^^^^^^^
+        helper()
+
+
+def test_patch_lambda_with_unused_star_args():
+    patch("app.api.fetch", lambda *args: 42)  # Noncompliant
+#                          ^^^^^^^^^^^^^^^^
+
+
+def test_patch_lambda_with_unused_kwargs():
+    patch("app.api.fetch", lambda **kwargs: 42)  # Noncompliant
+#                          ^^^^^^^^^^^^^^^^^^^
+
+
+def test_patch_lambda_with_unused_parameters():
+    patch("app.api.fetch", lambda x, y: 7)  # Noncompliant
+#                          ^^^^^^^^^^^^^^
+
+
+def test_patch_lambda_with_unused_default_parameter():
+    patch("app.api.fetch", lambda x=1: 7)  # Noncompliant
+#                          ^^^^^^^^^^^^^
+
+
+def test_patch_lambda_in_parentheses():
+    patch("app.api.fetch", (lambda: 42))  # Noncompliant
+#                           ^^^^^^^^^^
+
+
+def test_patch_object_positional_lambda():
+    patch.object(Target, "attribute", lambda: 42)  # Noncompliant
+#                                     ^^^^^^^^^^
+
+
+def test_patch_object_keyword_lambda():
+    patch.object(Target, "attribute", new=lambda: 42)  # Noncompliant
+#                                         ^^^^^^^^^^
+
+
+def test_fully_qualified_patch():
+    unittest.mock.patch("app.api.fetch", lambda: 42)  # Noncompliant
+#                                        ^^^^^^^^^^
+
+
+def test_third_party_mock_patch():
+    mock.patch("app.api.fetch", lambda: 42)  # Noncompliant
+#                               ^^^^^^^^^^
+
+
+@patch("app.api.fetch", lambda: 42)  # Noncompliant
+#                       ^^^^^^^^^^
+def test_patch_as_decorator(mocked):
+    helper()
+
+
+@patch("app.api.fetch", lambda *args: (helper(), None))
+def test_compliant_decorator_lambda_with_call(mocked):
+    # return_value= would evaluate the call at decoration time, not on each patch invocation
+    helper()
+
+
+@patch.object(Target, "attribute", lambda: helper())
+def test_compliant_decorator_object_lambda_with_call(mocked):
+    helper()
+
+
+def test_patch_lambda_with_call_not_decorator():
+    # Non-decorator patches keep the issue even when the body has a call (no quick fix offered)
+    with patch("app.api.fetch", lambda *args: (helper(), None)):  # Noncompliant
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        helper()
+
+
+def test_self_mocker_patch():
+    class TestX:
+        def setup_method(self, method, mocker):
+            self.mocker = mocker
+
+        def test_x(self):
+            self.mocker.patch("module.target", lambda: 7)  # Noncompliant
+#                                              ^^^^^^^^^
+
+
+def test_self_mocker_patch_object():
+    class TestX:
+        def setup_method(self, method, mocker):
+            self.mocker = mocker
+
+        def test_x(self):
+            self.mocker.patch.object(Target, "attribute", lambda: 7)  # Noncompliant
+#                                                         ^^^^^^^^^
+
+
+def test_mocker_patch(mocker):
+    mocker.patch("module.target", lambda: 7)  # Noncompliant
+#                                 ^^^^^^^^^
+
+
+def test_mocker_patch_object(mocker):
+    mocker.patch.object(Target, "attribute", lambda: 7)  # Noncompliant
+#                                            ^^^^^^^^^
+
+
+def test_session_mocker_patch(session_mocker):
+    session_mocker.patch("module.target", lambda: 7)  # Noncompliant
+#                                         ^^^^^^^^^
+
+
+def test_module_mocker_patch(module_mocker):
+    module_mocker.patch("module.target", lambda: 7)  # Noncompliant
+#                                        ^^^^^^^^^
+
+
+def test_class_mocker_patch(class_mocker):
+    class_mocker.patch("module.target", lambda: 7)  # Noncompliant
+#                                       ^^^^^^^^^
+
+
+def test_package_mocker_patch(package_mocker):
+    package_mocker.patch("module.target", lambda: 7)  # Noncompliant
+#                                         ^^^^^^^^^
+
+
+def test_lambda_returning_outer_name(mocker):
+    sentinel = object()
+    mocker.patch("module.target", lambda: sentinel)  # Noncompliant
+#                                 ^^^^^^^^^^^^^^^^
+
+
+def test_lambda_body_ignoring_its_parameter(mocker):
+    mocker.patch("module.target", lambda value: helper())  # Noncompliant
+#                                 ^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_lambda_returning_enclosing_parameter(mocker, expected):
+    mocker.patch("module.target", lambda value: expected)  # Noncompliant
+#                                 ^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_patch_lambda_with_unused_keyword_only_parameter():
+    patch("app.api.fetch", lambda *, value: 7)  # Noncompliant
+#                          ^^^^^^^^^^^^^^^^^^
+
+
+def test_multiline_lambda_body():
+    patch("app.api.fetch", lambda: {  # Noncompliant
+#                          ^[el=+3;ec=5]
+        "ok": True,
+    })
+
+
+def test_compliant_return_value():
+    with patch("app.api.fetch", return_value={"ok": True}):
+        helper()
+
+
+def test_compliant_lambda_using_parameters():
+    patch("app.api.fetch", lambda x, y: x + y)
+
+
+def test_compliant_lambda_using_star_args():
+    patch("app.api.fetch", lambda *args: args[0])
+
+
+def test_compliant_lambda_using_kwargs():
+    patch("app.api.fetch", lambda **kwargs: kwargs["value"])
+
+
+def test_compliant_lambda_using_parameter_in_nested_call(mocker):
+    mocker.patch("module.target", lambda value: helper(value))
+
+
+def test_compliant_identity_lambda():
+    patch("app.api.fetch", lambda value: value)
+
+
+def test_compliant_lambda_using_keyword_only_parameter():
+    patch("app.api.fetch", lambda *, value: value)
+
+
+def test_compliant_side_effect_lambda():
+    patch("app.api.fetch", side_effect=lambda: 42)
+
+
+def test_compliant_patch_with_named_function():
+    patch("app.api.fetch", helper)
+
+
+def test_compliant_patch_dict():
+    patch.dict("app.api.settings", {"a": 1})
+
+
+def test_compliant_patch_multiple():
+    patch.multiple("app.api", fetch=lambda: 42)
+
+
+def test_compliant_patch_with_unpacked_arguments(arguments):
+    patch("app.api.fetch", *arguments)
+
+
+def test_compliant_mocker_patch_return_value(mocker):
+    mocker.patch("module.target", return_value=7)
+
+
+def test_compliant_unrelated_receiver(unknown_object):
+    unknown_object.patch("module.target", lambda: 7)
+
+
+def test_compliant_patch_on_call_result():
+    helper().patch("module.target", lambda: 7)
+
+
+def test_compliant_object_on_unrelated_receiver(unknown_object):
+    unknown_object.object(Target, "attribute", lambda: 7)
+
+
+def test_compliant_object_on_unrelated_patch_owner():
+    helper.patch.object(Target, "attribute", lambda: 7)
+
+
+def test_compliant_object_on_unrelated_member():
+    helper.other.object(Target, "attribute", lambda: 7)
+
+
+def test_compliant_locally_assigned_mocker():
+    mocker = helper
+    mocker.patch("module.target", lambda: 7)
+
+
+def test_compliant_mocker_aliased_to_local(mocker):
+    # Accepted FN: local aliases of the mocker fixture are not tracked
+    m = mocker
+    m.patch("module.target", lambda: 7)
+
+
+def local_patch(target, new):
+    ...
+
+
+def test_compliant_locally_defined_patch():
+    local_patch("app.api.fetch", lambda: 42)
+
+
+def test_compliant_lambda_as_first_argument():
+    helper(lambda: 42)
diff --git a/python-checks/src/test/resources/checks/tests/mocksShouldUseAutospec.py b/python-checks/src/test/resources/checks/tests/mocksShouldUseAutospec.py
new file mode 100644
index 0000000000..f93d6ef24e
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/mocksShouldUseAutospec.py
@@ -0,0 +1,422 @@
+import mock
+import unittest.mock
+from unittest.mock import MagicMock, Mock, create_autospec, patch
+
+
+class PaymentGateway:
+    def charge(self, amount):
+        ...
+
+
+class ApiClient:
+    def fetch(self, id):
+        ...
+
+
+def checkout(payments, order):
+    ...
+
+
+def notify_user(user_id):
+    ...
+
+
+def test_bare_mock():
+    payments = Mock()  # Noncompliant {{Replace this "Mock()" with "create_autospec()", or pass "spec=" / "spec_set=".}}
+#              ^^^^
+    checkout(payments, None)
+
+
+def test_bare_magic_mock():
+    client = MagicMock()  # Noncompliant {{Replace this "MagicMock()" with "create_autospec()", or pass "spec=" / "spec_set=".}}
+#            ^^^^^^^^^
+    client.fetch("id")
+
+
+def test_mock_with_return_value_only():
+    # Discarded constructor — no collaborator interaction in the test.
+    Mock(return_value=42)
+
+
+def test_mock_with_side_effect_only():
+    Mock(side_effect=ValueError)
+
+
+def test_mock_with_name_only():
+    Mock(name="payments")
+
+
+def test_mock_with_wraps_only():
+    Mock(wraps=PaymentGateway())
+
+
+def test_fully_qualified_mock():
+    unittest.mock.Mock()
+
+
+def test_fully_qualified_magic_mock():
+    unittest.mock.MagicMock()
+
+
+def test_fully_qualified_mock_collaborator():
+    payments = unittest.mock.Mock()  # Noncompliant {{Replace this "Mock()" with "create_autospec()", or pass "spec=" / "spec_set=".}}
+#              ^^^^^^^^^^^^^^^^^^
+    checkout(payments, None)
+
+
+def test_third_party_mock():
+    mock.Mock()
+
+
+def test_third_party_magic_mock():
+    mock.MagicMock()
+
+
+def test_third_party_mock_collaborator():
+    payments = mock.Mock()  # Noncompliant {{Replace this "Mock()" with "create_autospec()", or pass "spec=" / "spec_set=".}}
+#              ^^^^^^^^^
+    checkout(payments, None)
+
+
+def test_patch_without_autospec():
+    with patch("app.notify.send") as send:  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#        ^^^^^
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
+
+def test_patch_as_decorator_unused_mock():
+    # Isolation-only patch: mock parameter is never used.
+    @patch("app.notify.send")
+    def inner(send):
+        notify_user("u1")
+
+    inner()
+
+
+def test_patch_as_decorator_used_mock():
+    @patch("app.notify.send")  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#    ^^^^^
+    def inner(send):
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
+    inner()
+
+
+def test_patch_object_without_autospec():
+    with patch.object(PaymentGateway, "charge") as charge:  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#        ^^^^^^^^^^^^
+        charge(10)
+
+
+def test_fully_qualified_patch_unused():
+    # No mock bound in the test — isolation only.
+    with unittest.mock.patch("app.notify.send"):
+        notify_user("u1")
+
+
+def test_third_party_patch_unused():
+    with mock.patch("app.notify.send"):
+        notify_user("u1")
+
+
+def test_mocker_patch_unused(mocker):
+    mocker.patch("app.notify.send")
+
+
+def test_mocker_patch_object_unused(mocker):
+    mocker.patch.object(PaymentGateway, "charge")
+
+
+def test_class_mocker_patch_unused(class_mocker):
+    class_mocker.patch("app.notify.send")
+
+
+def test_self_mocker_patch_unused():
+    class Suite:
+        def setup_method(self, mocker):
+            self.mocker = mocker
+
+        def test_it(self):
+            self.mocker.patch("app.notify.send")
+
+
+def test_mocker_patch_used(mocker):
+    send = mocker.patch("app.notify.send")  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#          ^^^^^^^^^^^^
+    notify_user("u1")
+    send.assert_called_once_with("u1")
+
+
+def test_patch_with_autospec_false_unused():
+    # Isolation-only; autospec=False is irrelevant when the mock is unused.
+    with patch("app.notify.send", autospec=False):
+        notify_user("u1")
+
+
+def test_patch_with_autospec_false_used():
+    with patch("app.notify.send", autospec=False) as send:  # Noncompliant {{Replace "autospec=False" with "autospec=True", or pass an explicit "spec=" / "spec_set=".}}
+#        ^^^^^
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
+
+def test_field_stub_mock_not_raised():
+    # Autospec cannot mirror instance fields populated in __init__.
+    message = Mock()
+    message.headers = {"id": "1"}
+    message.body = b""
+
+
+def test_field_stub_magic_mock_not_raised():
+    response = MagicMock()
+    response.status_code = 200
+    response.raw = MagicMock()
+
+
+def test_nested_mock_assigned_to_attribute():
+    cur = Mock()
+    connect = MagicMock()
+    connect.return_value.cursor = cur
+    cur.return_value.execute = Mock()
+    cur.return_value.execute.assert_called()
+
+
+def test_compliant_create_autospec():
+    payments = create_autospec(PaymentGateway)
+    checkout(payments, None)
+
+
+def test_compliant_create_autospec_fully_qualified():
+    client = unittest.mock.create_autospec(ApiClient)
+    client.fetch("id")
+
+
+def test_compliant_mock_with_spec():
+    payments = Mock(spec=PaymentGateway)
+    checkout(payments, None)
+
+
+def test_compliant_mock_with_positional_spec():
+    payments = Mock(PaymentGateway)
+    checkout(payments, None)
+
+
+def test_compliant_mock_with_spec_set():
+    payments = Mock(spec_set=PaymentGateway)
+    checkout(payments, None)
+
+
+def test_compliant_magic_mock_with_spec():
+    client = MagicMock(spec=ApiClient)
+    client.fetch("id")
+
+
+def test_compliant_magic_mock_with_spec_set():
+    client = MagicMock(spec_set=ApiClient)
+    client.fetch("id")
+
+
+def test_compliant_patch_autospec_true():
+    with patch("app.notify.send", autospec=True) as send:
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
+
+def test_compliant_patch_autospec_class():
+    with patch("app.notify.send", autospec=PaymentGateway):
+        notify_user("u1")
+
+
+def test_compliant_patch_with_spec():
+    with patch("app.notify.send", spec=PaymentGateway):
+        notify_user("u1")
+
+
+def test_compliant_patch_with_spec_set():
+    with patch("app.notify.send", spec_set=PaymentGateway):
+        notify_user("u1")
+
+
+def test_compliant_patch_object_autospec():
+    with patch.object(PaymentGateway, "charge", autospec=True):
+        ...
+
+
+def test_compliant_patch_with_new():
+    real = lambda user_id: None
+    with patch("app.notify.send", new=real):
+        notify_user("u1")
+
+
+def test_compliant_patch_with_new_callable():
+    with patch("app.notify.send", new_callable=lambda: lambda user_id: None):
+        notify_user("u1")
+
+
+def test_compliant_mocker_patch_autospec(mocker):
+    mocker.patch("app.notify.send", autospec=True)
+
+
+def test_compliant_mocker_patch_object_autospec(mocker):
+    mocker.patch.object(PaymentGateway, "charge", autospec=True)
+
+
+def test_compliant_decorator_autospec():
+    @patch("app.notify.send", autospec=True)
+    def inner(send):
+        notify_user("u1")
+
+    inner()
+
+
+def test_ignored_when_unpacked_kwargs():
+    kwargs = {"autospec": True}
+    Mock(**kwargs)
+    patch("app.notify.send", **kwargs)
+
+
+def test_async_mock_not_covered():
+    # RSpec only mentions Mock / MagicMock
+    unittest.mock.AsyncMock()
+
+
+def test_property_mock_not_covered():
+    unittest.mock.PropertyMock()
+
+
+def test_annotated_assignment_collaborator():
+    payments: object = Mock()  # Noncompliant {{Replace this "Mock()" with "create_autospec()", or pass "spec=" / "spec_set=".}}
+#                      ^^^^
+    checkout(payments, None)
+
+
+def test_chained_assignment_collaborator():
+    payments = gateway = Mock()  # Noncompliant {{Replace this "Mock()" with "create_autospec()", or pass "spec=" / "spec_set=".}}
+#                        ^^^^
+    checkout(payments, None)
+
+
+def test_inline_mock_argument():
+    checkout(Mock(), None)  # Noncompliant {{Replace this "Mock()" with "create_autospec()", or pass "spec=" / "spec_set=".}}
+#            ^^^^
+
+
+def test_mock_called_directly():
+    factory = Mock()  # Noncompliant {{Replace this "Mock()" with "create_autospec()", or pass "spec=" / "spec_set=".}}
+#             ^^^^
+    factory()
+
+
+def test_fully_qualified_decorator_used():
+    @unittest.mock.patch("app.notify.send")  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#    ^^^^^^^^^^^^^^^^^^^
+    def inner(send):
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
+    inner()
+
+
+def test_patch_object_decorator_used():
+    @patch.object(PaymentGateway, "charge")  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#    ^^^^^^^^^^^^
+    def inner(charge):
+        charge(10)
+
+    inner()
+
+
+@patch("app.notify.send")  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#^^^^^
+class ClassLevelPatchSuite:
+    def test_it(self, send):
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
+
+def test_decorator_without_mock_parameter():
+    # More patch decorators than injectable parameters — treat as unused.
+    @patch("app.notify.send")
+    def inner():
+        notify_user("u1")
+
+    inner()
+
+
+def test_tuple_unpacking_mock_not_raised():
+    # Unpacking yields child mocks, not the constructed mock itself.
+    payments, order = Mock()
+    checkout(payments, order)
+
+
+def test_attribute_lhs_mock_not_raised_as_binding():
+    gateway = PaymentGateway()
+    gateway.charge = Mock()
+    gateway.charge(10)
+
+
+def test_patch_decorator_with_non_call_neighbor():
+    # Non-call decorators must not break patch index → parameter mapping.
+    @staticmethod
+    @patch("app.notify.send")  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#    ^^^^^
+    def inner(send):
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+
+    inner()
+
+
+def test_parenthesized_mock_assignment():
+    payments = (Mock())  # Noncompliant {{Replace this "Mock()" with "create_autospec()", or pass "spec=" / "spec_set=".}}
+#               ^^^^
+    checkout(payments, None)
+
+
+def test_classmethod_patch_skips_cls_parameter():
+    class Suite:
+        @classmethod
+        @patch("app.notify.send")  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#        ^^^^^
+        def inner(cls, send):
+            notify_user("u1")
+            send.assert_called_once_with("u1")
+
+    Suite.inner()
+
+
+def test_instance_method_patch_skips_self_parameter():
+    class Suite:
+        @patch("app.notify.send")  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#        ^^^^^
+        def inner(self, send):
+            notify_user("u1")
+            send.assert_called_once_with("u1")
+
+    Suite().inner()
+
+
+def test_with_patch_non_name_alias_ignored():
+    # Alias is not a simple name — cannot track usages; treat as unused.
+    class Box:
+        pass
+
+    box = Box()
+    with patch("app.notify.send") as box.send:
+        notify_user("u1")
+
+
+def test_nested_mock_inside_mock_constructor():
+    # Inner Mock is an argument to another Mock — not a collaborator use.
+    Mock(Mock())
+
+
+def test_patch_call_nested_inside_with_patch():
+    # Inner patch is not the with-item test; isolation-only unless assigned/used.
+    with patch("app.notify.send") as send:  # Noncompliant {{Add "autospec=True" to this patch call, or pass an explicit "spec=" / "spec_set=".}}
+#        ^^^^^
+        notify_user("u1")
+        send.assert_called_once_with("u1")
+        patch("app.notify.other")
diff --git a/python-checks/src/test/resources/checks/tests/package/__init__.py b/python-checks/src/test/resources/checks/tests/package/__init__.py
new file mode 100644
index 0000000000..5488f730f6
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/package/__init__.py
@@ -0,0 +1 @@
+pytest_plugins = ["pytest_cov"]  # Noncompliant {{"pytest_plugins" should be defined in conftest.py files}}
diff --git a/python-checks/src/test/resources/checks/tests/pytestAutouseParametrizedFixture.py b/python-checks/src/test/resources/checks/tests/pytestAutouseParametrizedFixture.py
new file mode 100644
index 0000000000..b53ac37df9
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestAutouseParametrizedFixture.py
@@ -0,0 +1,59 @@
+import pytest
+from pytest import fixture
+
+
+@pytest.fixture(autouse=True, params=[1, 2, 3])  # Noncompliant {{Remove the "params" argument or set "autouse" to False.}}
+def noncompliant_module_fixture():
+    return "value"
+
+
+@pytest.fixture(params=[1, 2, 3], autouse=True)  # Noncompliant
+def noncompliant_reordered_arguments():
+    return "value"
+
+
+@pytest.fixture(autouse=True)
+def compliant_autouse_only():
+    return "value"
+
+
+@pytest.fixture(params=[1, 2, 3])
+def compliant_params_only(request):
+    return request.param
+
+
+@pytest.fixture(autouse=False, params=[1, 2, 3])
+def compliant_autouse_false_with_params():
+    return "value"
+
+
+@pytest.fixture(autouse=True, params=[])
+def compliant_empty_params():
+    return "value"
+
+
+@pytest.fixture(autouse=True, params=None)
+def compliant_none_params():
+    return "value"
+
+
+@pytest.fixture
+def compliant_no_arguments():
+    return "value"
+
+
+class TestSomething:
+    @pytest.fixture(autouse=True, params=[1, 2])  # Noncompliant
+    def noncompliant_class_fixture(self):
+        pass
+
+
+@fixture(autouse=True, params=[1])  # Noncompliant
+def noncompliant_imported_fixture():
+    return "value"
+
+
+PARAMS = [1, 2]
+@pytest.fixture(autouse=True, params=PARAMS)  # Noncompliant
+def noncompliant_params_from_variable():
+    return "value"
diff --git a/python-checks/src/test/resources/checks/tests/pytestDecoratorParentheses.py b/python-checks/src/test/resources/checks/tests/pytestDecoratorParentheses.py
new file mode 100644
index 0000000000..28ba515922
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestDecoratorParentheses.py
@@ -0,0 +1,174 @@
+import functools
+
+import pytest
+from pytest import fixture, mark
+from pytest.mark import skip
+
+
+@pytest.fixture()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#              ^^
+def empty_parens_fixture():
+    return 1
+
+
+@pytest.mark.slow()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#                ^^
+def test_empty_parens_custom_mark():
+    assert True
+
+
+@pytest.mark.skip()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#                ^^
+def test_empty_parens_known_mark():
+    assert True
+
+
+@pytest.mark.usefixtures()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#                       ^^
+def test_empty_parens_usefixtures():
+    assert True
+
+
+@fixture()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#       ^^
+def empty_parens_imported_fixture():
+    return 1
+
+
+@mark.slow()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#         ^^
+def test_empty_parens_imported_mark():
+    assert True
+
+
+@skip()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#    ^^
+def test_empty_parens_imported_skip():
+    assert True
+
+
+@pytest.fixture ()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#               ^^
+def empty_parens_with_space_fixture():
+    return 1
+
+
+@pytest.mark.slow()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#                ^^
+class TestEmptyParensOnClass:
+    @pytest.fixture()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#                  ^^
+    def resource(self):
+        return 1
+
+
+@pytest.mark.slow()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#                ^^
+@pytest.mark.usefixtures("db")
+@pytest.fixture()  # Noncompliant {{Remove empty parentheses from this decorator.}}
+#              ^^
+def several_decorators():
+    return 1
+
+
+# Compliant: no parentheses at all, which is the default expected style
+@pytest.fixture
+def bare_fixture():
+    return 1
+
+
+@pytest.mark.slow
+def test_bare_custom_mark():
+    assert True
+
+
+@pytest.mark.skip
+def test_bare_known_mark():
+    assert True
+
+
+@pytest.mark.usefixtures
+def test_bare_usefixtures():
+    assert True
+
+
+@fixture
+def bare_imported_fixture():
+    return 1
+
+
+@mark.slow
+def test_bare_imported_mark():
+    assert True
+
+
+@pytest.mark.slow
+class TestBareMarkOnClass:
+    @pytest.fixture
+    def resource(self):
+        return 1
+
+
+# Compliant: decorators with arguments keep their parentheses
+@pytest.fixture(scope="module")
+def scoped_fixture():
+    return 1
+
+
+@pytest.fixture(name="renamed", autouse=True)
+def named_fixture():
+    return 1
+
+
+@pytest.mark.parametrize("value", [1, 2])
+def test_parametrized(value):
+    assert value
+
+
+@pytest.mark.skip(reason="not ready")
+def test_skipped():
+    assert False
+
+
+@pytest.mark.usefixtures("db")
+def test_with_usefixtures():
+    assert True
+
+
+@pytest.mark.slow(1)
+def test_mark_with_argument():
+    assert True
+
+
+def make_options():
+    return {"scope": "session"}
+
+
+@pytest.fixture(**make_options())
+def unpacked_options_fixture():
+    return 1
+
+
+# Compliant: not pytest decorators
+@functools.cache()
+def cached():
+    return 1
+
+
+@functools.cache
+def also_cached():
+    return 1
+
+
+def my_decorator(func):
+    return func
+
+
+@my_decorator
+def decorated():
+    return 1
+
+
+@my_decorator()
+def decorated_with_parens():
+    return 1
diff --git a/python-checks/src/test/resources/checks/tests/pytestDecoratorParenthesesRequired.py b/python-checks/src/test/resources/checks/tests/pytestDecoratorParenthesesRequired.py
new file mode 100644
index 0000000000..a6fb89bb75
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestDecoratorParenthesesRequired.py
@@ -0,0 +1,108 @@
+import functools
+
+import pytest
+from pytest import fixture, mark
+from pytest.mark import skip
+
+
+@pytest.fixture  # Noncompliant {{Add empty parentheses to this decorator.}}
+#^^^^^^^^^^^^^^
+def bare_fixture():
+    return 1
+
+
+@pytest.mark.slow  # Noncompliant {{Add empty parentheses to this decorator.}}
+#^^^^^^^^^^^^^^^^
+def test_bare_custom_mark():
+    assert True
+
+
+@pytest.mark.skip  # Noncompliant {{Add empty parentheses to this decorator.}}
+#^^^^^^^^^^^^^^^^
+def test_bare_known_mark():
+    assert True
+
+
+@pytest.mark.usefixtures  # Noncompliant {{Add empty parentheses to this decorator.}}
+#^^^^^^^^^^^^^^^^^^^^^^^
+def test_bare_usefixtures():
+    assert True
+
+
+@fixture  # Noncompliant {{Add empty parentheses to this decorator.}}
+#^^^^^^^
+def bare_imported_fixture():
+    return 1
+
+
+@mark.slow  # Noncompliant {{Add empty parentheses to this decorator.}}
+#^^^^^^^^^
+def test_bare_imported_mark():
+    assert True
+
+
+@skip  # Noncompliant {{Add empty parentheses to this decorator.}}
+#^^^^
+def test_bare_imported_skip():
+    assert True
+
+
+@pytest.mark.slow  # Noncompliant {{Add empty parentheses to this decorator.}}
+#^^^^^^^^^^^^^^^^
+class TestBareMarkOnClass:
+    @pytest.fixture  # Noncompliant {{Add empty parentheses to this decorator.}}
+#    ^^^^^^^^^^^^^^
+    def resource(self):
+        return 1
+
+
+# Compliant: parentheses are present, which is the configured expected style
+@pytest.fixture()
+def empty_parens_fixture():
+    return 1
+
+
+@pytest.mark.slow()
+def test_empty_parens_custom_mark():
+    assert True
+
+
+@fixture()
+def empty_parens_imported_fixture():
+    return 1
+
+
+@mark.slow()
+def test_empty_parens_imported_mark():
+    assert True
+
+
+# Compliant: decorators with arguments already have parentheses
+@pytest.fixture(scope="module")
+def scoped_fixture():
+    return 1
+
+
+@pytest.mark.parametrize("value", [1, 2])
+def test_parametrized(value):
+    assert value
+
+
+@pytest.mark.usefixtures("db")
+def test_with_usefixtures():
+    assert True
+
+
+# Compliant: not pytest decorators
+@functools.cache
+def cached():
+    return 1
+
+
+def my_decorator(func):
+    return func
+
+
+@my_decorator
+def decorated():
+    return 1
diff --git a/python-checks/src/test/resources/checks/tests/pytestDefaultFixtureScope.py b/python-checks/src/test/resources/checks/tests/pytestDefaultFixtureScope.py
new file mode 100644
index 0000000000..0b4d570190
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestDefaultFixtureScope.py
@@ -0,0 +1,99 @@
+import pytest
+from pytest import fixture
+
+
+@pytest.fixture(scope="function")  # Noncompliant {{Remove this redundant scope="function" argument.}}
+#               ^^^^^^^^^^^^^^^^
+def noncompliant_default_scope():
+    return {}
+
+
+@pytest.fixture(scope='function')  # Noncompliant
+#               ^^^^^^^^^^^^^^^^
+def noncompliant_single_quotes():
+    return {}
+
+
+@pytest.fixture(scope="function", autouse=True)  # Noncompliant
+#               ^^^^^^^^^^^^^^^^
+def noncompliant_with_other_args():
+    return {}
+
+
+@pytest.fixture(autouse=True, scope="function")  # Noncompliant
+#                             ^^^^^^^^^^^^^^^^
+def noncompliant_scope_last():
+    return {}
+
+
+@fixture(scope="function")  # Noncompliant
+#        ^^^^^^^^^^^^^^^^
+def noncompliant_imported_fixture():
+    return {}
+
+
+class TestSomething:
+    @pytest.fixture(scope="function")  # Noncompliant
+    #               ^^^^^^^^^^^^^^^^
+    def noncompliant_class_fixture(self):
+        return {}
+
+
+@pytest.fixture(
+    scope="function",  # Noncompliant
+#   ^^^^^^^^^^^^^^^^
+)
+def noncompliant_multiline():
+    return {}
+
+
+@pytest.fixture
+def compliant_no_args():
+    return {}
+
+
+@pytest.fixture()
+def compliant_empty_parens():
+    return {}
+
+
+@pytest.fixture(scope="module")
+def compliant_module_scope():
+    return {}
+
+
+@pytest.fixture(scope="class")
+def compliant_class_scope():
+    return {}
+
+
+@pytest.fixture(scope="session")
+def compliant_session_scope():
+    return {}
+
+
+@pytest.fixture(scope="package")
+def compliant_package_scope():
+    return {}
+
+
+@pytest.fixture(autouse=True)
+def compliant_autouse_only():
+    return {}
+
+
+@pytest.fixture(name="renamed")
+def compliant_other_options():
+    return {}
+
+
+SCOPE = "function"
+
+
+@pytest.fixture(scope=SCOPE)
+def compliant_scope_from_variable():
+    return {}
+
+
+def not_a_fixture(scope="function"):
+    return scope
diff --git a/python-checks/src/test/resources/checks/tests/pytestFixtureMultipleYield.py b/python-checks/src/test/resources/checks/tests/pytestFixtureMultipleYield.py
new file mode 100644
index 0000000000..bd423fb739
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestFixtureMultipleYield.py
@@ -0,0 +1,219 @@
+import pytest
+
+
+@pytest.fixture
+def database_connection():
+    db = create_connection()
+    yield db
+    yield db  # Noncompliant {{Pytest fixtures should contain at most one yield statement.}}
+#   ^^^^^^^^
+    db.close()
+
+
+@pytest.fixture
+def single_yield_fixture():
+    resource = acquire()
+    yield resource
+    release(resource)
+
+
+@pytest.fixture
+def return_only_fixture():
+    return create_connection()
+
+
+def generator_with_multiple_yields():
+    yield 1
+    yield 2
+
+
+@pytest.fixture()
+def fixture_with_call_decorator():
+    value = setup()
+    yield value
+    teardown(value)
+
+
+@pytest.fixture
+def fixture_with_nested_generator():
+    def inner():
+        yield 1
+        yield 2
+
+    inner()
+    yield "ok"
+
+
+@pytest.fixture
+def triple_yield_fixture():
+    yield 1
+    yield 2  # Noncompliant {{Pytest fixtures should contain at most one yield statement.}}
+#   ^^^^^^^
+    yield 3  # Noncompliant {{Pytest fixtures should contain at most one yield statement.}}
+#   ^^^^^^^
+
+
+import unittest
+
+
+class MyTest(unittest.TestCase):
+
+    @pytest.fixture
+    def class_fixture(self):
+        yield "setup"
+        yield "again"  # Noncompliant {{Pytest fixtures should contain at most one yield statement.}}
+#       ^^^^^^^^^^^^^
+        self.teardown()
+
+
+
+from pytest import fixture as pytest_fixture
+
+
+@pytest_fixture
+def imported_fixture_decorator():
+    value = setup()
+    yield value
+    yield value  # Noncompliant {{Pytest fixtures should contain at most one yield statement.}}
+#   ^^^^^^^^^^^
+    teardown(value)
+
+
+@pytest.fixture
+def exclusive_branch_yields(condition):
+    if condition:
+        yield "a"
+    else:
+        yield "b"
+
+
+@pytest.fixture
+def yield_then_return_on_branch(terminal_reporter):
+    if terminal_reporter is None:
+        yield
+        return
+    yield "value"
+
+
+@pytest.fixture
+def sequential_after_non_exiting_if(condition):
+    if condition:
+        yield "a"
+    yield "b"  # Noncompliant {{Pytest fixtures should contain at most one yield statement.}}
+#   ^^^^^^^^^
+
+
+@pytest.fixture
+def try_except_exclusive_yields():
+    try:
+        risky()
+        yield "try-path"
+    except ValueError:
+        yield "except-path"
+
+
+@pytest.fixture
+def try_body_with_two_yields():
+    try:
+        yield 1
+        yield 2  # Noncompliant {{Pytest fixtures should contain at most one yield statement.}}
+#       ^^^^^^^
+    except ValueError:
+        pass
+
+
+@pytest.fixture
+def elif_chain_exclusive_yields(mode):
+    if mode == 1:
+        yield "first"
+    elif mode == 2:
+        yield "second"
+    else:
+        yield "third"
+
+
+@pytest.fixture
+def with_block_single_yield():
+    with open("resource.txt") as resource:
+        yield resource
+
+
+@pytest.fixture
+def for_loop_single_yield(items):
+    for item in items:
+        yield item
+
+
+@pytest.fixture
+def nested_return_skips_following_yield(flag):
+    if flag:
+        return
+    yield "value"
+
+
+@pytest.fixture
+def while_loop_yield():
+    while cond():
+        yield next_item()
+
+
+@pytest.fixture
+def try_else_single_yield():
+    try:
+        work()
+    except ValueError:
+        pass
+    else:
+        yield "done"
+
+
+@pytest.fixture
+def try_finally_double_yield():
+    try:
+        yield "a"
+    finally:
+        yield "b"  # Noncompliant {{Pytest fixtures should contain at most one yield statement.}}
+#       ^^^^^^^^^
+
+
+@pytest.fixture
+def try_finally_single_yield():
+    try:
+        work()
+    finally:
+        cleanup()
+    yield "done"
+
+
+@pytest.fixture
+def nested_function_yields_ignored():
+    def inner():
+        yield 1
+        yield 2
+
+    yield "outer"
+
+
+@pytest.fixture
+def elif_branch_returns(mode):
+    if mode == 1:
+        pass
+    elif mode == 2:
+        return
+    yield "value"
+
+
+@pytest.fixture
+def raise_exits_branch(flag):
+    if flag:
+        raise ValueError("stop")
+    yield "ok"
+
+
+@pytest.fixture
+def for_with_else_yield(items):
+    for item in items:
+        if item:
+            return
+    else:
+        yield "done"
diff --git a/python-checks/src/test/resources/checks/tests/pytestFixtureMultipleYieldNonFixture.py b/python-checks/src/test/resources/checks/tests/pytestFixtureMultipleYieldNonFixture.py
new file mode 100644
index 0000000000..d6fbb006cb
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestFixtureMultipleYieldNonFixture.py
@@ -0,0 +1,3 @@
+def generator_with_multiple_yields():
+    yield 1
+    yield 2
diff --git a/python-checks/src/test/resources/checks/tests/pytestFixturePositionalArgs.py b/python-checks/src/test/resources/checks/tests/pytestFixturePositionalArgs.py
new file mode 100644
index 0000000000..020434f16c
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestFixturePositionalArgs.py
@@ -0,0 +1,90 @@
+import pytest
+from pytest import fixture
+
+
+@pytest.fixture("module")  # Noncompliant {{Pass fixture options as keyword arguments.}}
+#               ^^^^^^^^
+def noncompliant_positional_scope():
+    return []
+
+
+@pytest.fixture(True)  # Noncompliant
+#               ^^^^
+def noncompliant_positional_autouse():
+    return []
+
+
+@pytest.fixture("module", True)  # Noncompliant
+#               ^^^^^^^^
+def noncompliant_multiple_positionals():
+    return []
+
+
+@pytest.fixture("module", autouse=True)  # Noncompliant
+#               ^^^^^^^^
+def noncompliant_mixed_positional_and_keyword():
+    return []
+
+
+OPTS = ("module",)
+@pytest.fixture(*OPTS)  # Noncompliant
+#               ^^^^^
+def noncompliant_unpacked_positional():
+    return []
+
+
+@fixture("session")  # Noncompliant
+#        ^^^^^^^^^
+def noncompliant_imported_fixture():
+    return []
+
+
+class TestSomething:
+    @pytest.fixture("class")  # Noncompliant
+    #               ^^^^^^^
+    def noncompliant_class_fixture(self):
+        return []
+
+
+@pytest.fixture(scope="module")
+def compliant_keyword_scope():
+    return []
+
+
+@pytest.fixture(autouse=True)
+def compliant_keyword_autouse():
+    return []
+
+
+@pytest.fixture(scope="module", autouse=True)
+def compliant_multiple_keywords():
+    return []
+
+
+@pytest.fixture()
+def compliant_empty_call():
+    return []
+
+
+@pytest.fixture
+def compliant_no_parentheses():
+    return []
+
+
+@pytest.fixture(**{"scope": "module"})
+def compliant_unpacked_keywords():
+    return []
+
+
+@fixture(scope="function")
+def compliant_imported_fixture():
+    return []
+
+
+def not_a_fixture(*args):
+    pass
+
+
+@not_a_fixture("module")
+def decorated_with_unrelated_call():
+    pass
diff --git a/python-checks/src/test/resources/checks/tests/pytestFixtureYieldTeardown.py b/python-checks/src/test/resources/checks/tests/pytestFixtureYieldTeardown.py
new file mode 100644
index 0000000000..d92a4991e6
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestFixtureYieldTeardown.py
@@ -0,0 +1,200 @@
+import pytest
+
+
+@pytest.fixture
+def with_finalizer(request):
+    resource = open_resource()
+    request.addfinalizer(resource.close)  # Noncompliant {{Replace this "request.addfinalizer()" call with a yield-based teardown.}}
+#   ^^^^^^^^^^^^^^^^^^^^
+    return resource
+
+
+@pytest.fixture(scope="module")
+def with_finalizer_and_scope(request):
+    resource = open_resource()
+    request.addfinalizer(resource.close)  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^
+    return resource
+
+
+@pytest.fixture
+def finalizer_without_return(request):
+    setup()
+    request.addfinalizer(teardown)  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^
+
+
+@pytest.fixture
+def several_finalizers(request):
+    # Multi-resource staged addfinalizer is a legitimate pytest pattern for partial-failure
+    # safety (cleanup already registered if a later connect raises). Still reported to stay
+    # aligned with Ruff PT021; suppress intentionally when that tradeoff is deliberate.
+    first = open_resource()
+    second = open_resource()
+    request.addfinalizer(first.close)  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^
+    request.addfinalizer(second.close)  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^
+    return first, second
+
+
+@pytest.fixture
+def finalizer_in_nested_block(request, flag):
+    resource = open_resource()
+    if flag:
+        request.addfinalizer(resource.close)  # Noncompliant
+#       ^^^^^^^^^^^^^^^^^^^^
+    return resource
+
+
+@pytest.fixture
+def finalizer_with_lambda(request):
+    resource = open_resource()
+    request.addfinalizer(lambda: resource.close())  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^
+    return resource
+
+
+@pytest.fixture
+def bare_yield_with_finalizer(request):
+    resource = open_resource()
+    request.addfinalizer(resource.close)  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^
+    yield
+
+
+@pytest.fixture
+def yield_teardown():
+    resource = open_resource()
+    yield resource
+    resource.close()
+
+
+@pytest.fixture
+def yield_and_finalizer(request):
+    resource = open_resource()
+    request.addfinalizer(resource.close)
+    yield resource
+
+
+@pytest.fixture
+def factory_as_fixture(request):
+    created = []
+
+    def make_resource(name):
+        resource = open_resource(name)
+        request.addfinalizer(resource.close)
+        created.append(resource)
+        return resource
+
+    return make_resource
+
+
+@pytest.fixture
+def factory_as_lambda(request):
+    return lambda name: request.addfinalizer(open_resource(name).close)
+
+
+@pytest.fixture
+def no_teardown_at_all():
+    return open_resource()
+
+
+def test_something(request):
+    resource = open_resource()
+    request.addfinalizer(resource.close)
+    assert resource is not None
+
+
+def helper_registering_finalizer(request):
+    request.addfinalizer(cleanup)
+
+
+@pytest.fixture
+def finalizer_on_other_object(monkeypatch):
+    monkeypatch.addfinalizer(cleanup)
+    return monkeypatch
+
+
+@pytest.fixture
+def other_request_method(request):
+    return request.getfixturevalue("with_finalizer")
+
+
+class TestResources:
+
+    @pytest.fixture
+    def fixture_in_class(self, request):
+        resource = open_resource()
+        request.addfinalizer(resource.close)  # Noncompliant
+#       ^^^^^^^^^^^^^^^^^^^^
+        return resource
+
+    @pytest.fixture
+    def yielding_fixture_in_class(self):
+        resource = open_resource()
+        yield resource
+        resource.close()
+
+
+from pytest import fixture as aliased_fixture
+
+
+@aliased_fixture
+def fixture_with_aliased_decorator(request):
+    resource = open_resource()
+    request.addfinalizer(resource.close)  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^
+    return resource
+
+
+def not_a_fixture_but_named_request(request):
+    request.addfinalizer(cleanup)
+
+
+@some_other_decorator
+def decorated_but_not_fixture(request):
+    request.addfinalizer(cleanup)
+
+
+# Accepted FNs below — documented limitations, not expected to raise.
+
+@pytest.fixture
+def finalizer_in_local_helper(request):
+    # FN: nested function skipped to avoid flagging factory-as-fixture; eager helpers are missed too.
+    def register(res):
+        request.addfinalizer(res.close)
+    resource = open_resource()
+    register(resource)
+    return resource
+
+
+def _register_cleanup(request, resource):
+    request.addfinalizer(resource.close)
+
+
+@pytest.fixture
+def finalizer_via_shared_helper(request):
+    # FN: addfinalizer call lives outside the fixture body.
+    resource = open_resource()
+    _register_cleanup(request, resource)
+    return resource
+
+
+@pytest.fixture
+def finalizer_via_request_node(request):
+    # FN: request.node.addfinalizer is a rare non-idiomatic spelling of the same API.
+    resource = open_resource()
+    request.node.addfinalizer(resource.close)
+    return resource
+
+
+import pytest_asyncio
+
+
+@pytest_asyncio.fixture
+async def finalizer_in_async_fixture(request):
+    # FN: only pytest.fixture is recognized, not pytest_asyncio.fixture.
+    resource = await open_resource()
+    request.addfinalizer(resource.close)
+    return resource
diff --git a/python-checks/src/test/resources/checks/tests/pytestModuleImport.py b/python-checks/src/test/resources/checks/tests/pytestModuleImport.py
new file mode 100644
index 0000000000..27a76a3419
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestModuleImport.py
@@ -0,0 +1,37 @@
+from pytest import mark, raises  # Noncompliant {{Import "pytest" as a module.}}
+#^[sc=1;ec=31]
+from pytest import approx as approximately  # Noncompliant
+#^[sc=1;ec=42]
+from pytest import *  # Noncompliant
+#^[sc=1;ec=20]
+from pytest.foo import bar  # Noncompliant
+#^[sc=1;ec=26]
+import pytest as pt  # Noncompliant {{Do not alias the "pytest" module.}}
+#      ^^^^^^^^^^^^
+import os, pytest as pt2  # Noncompliant
+#          ^^^^^^^^^^^^^
+import pytest.foo as pf  # Noncompliant
+#      ^^^^^^^^^^^^^^^^
+
+import pytest
+import pytest.foo
+import os, pytest
+import pytest as pytest  # explicit re-export, no renaming
+
+import pytest_asyncio as pytest_async
+from pytest_mock import MockerFixture
+from _pytest.monkeypatch import MonkeyPatch
+from pytest_django.asserts import assertNumQueries
+from mypytest import something
+from unittest import mock
+
+
+def local_imports():
+    from pytest import fixture  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^
+    import pytest as inner  # Noncompliant
+#          ^^^^^^^^^^^^^^^
+    import pytest
+    from . import pytest
+    from .pytest import helper
+    from ..pytest.utils import helper2
diff --git a/python-checks/src/test/resources/checks/tests/pytestParameterDefaultValueNonPytestFile.py b/python-checks/src/test/resources/checks/tests/pytestParameterDefaultValueNonPytestFile.py
new file mode 100644
index 0000000000..881ababb32
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestParameterDefaultValueNonPytestFile.py
@@ -0,0 +1,8 @@
+# Non-pytest-named production module: test_* helpers with defaults must not be flagged
+def test_connection(timeout=30):
+    return timeout
+
+
+class Client:
+    def test_endpoint(self, retries=3):
+        return retries
diff --git a/python-checks/src/test/resources/checks/tests/pytestRaisesContextManager.py b/python-checks/src/test/resources/checks/tests/pytestRaisesContextManager.py
new file mode 100644
index 0000000000..20fb897d71
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestRaisesContextManager.py
@@ -0,0 +1,265 @@
+import contextlib
+
+import pytest
+from pytest import raises as imported_raises
+
+
+def process_data(data):
+    return data.upper()
+
+
+def bootstrap_session(df=10):
+    if df <= 0:
+        raise ValueError('df must be positive')
+    if df > 20:
+        raise NotImplementedError('df > 20 not supported')
+
+
+def test_standalone_raises():
+    pytest.raises(ValueError)  # Noncompliant {{Prefer the context manager form: wrap the raising code in "with pytest.raises(...)".}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^
+    process_data('hello')
+
+
+def test_standalone_raises_with_match():
+    pytest.raises(ValueError, match="must be positive")  # Noncompliant {{Prefer the context manager form: wrap the raising code in "with pytest.raises(...)".}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    bootstrap_session(df=-1)
+
+
+def test_deprecated_callable_passing_form():
+    pytest.raises(ValueError, bootstrap_session, df=-1)  # Noncompliant {{Prefer the context manager form: wrap the raising code in "with pytest.raises(...)".}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_typo_calling_function_immediately():
+    pytest.raises(NotImplementedError, bootstrap_session(df=10))  # Noncompliant {{Prefer the context manager form: wrap the raising code in "with pytest.raises(...)".}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_deprecated_callable_even_when_assigned():
+    # Deprecated callable form is always reported, even if assigned.
+    ctx = pytest.raises(ValueError, bootstrap_session, df=-1)  # Noncompliant {{Prefer the context manager form: wrap the raising code in "with pytest.raises(...)".}}
+#         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    process_data('hello')
+
+
+def test_compliant_with_block():
+    with pytest.raises(ValueError):
+        process_data(123)
+
+
+def test_compliant_with_block_and_match():
+    with pytest.raises(ValueError, match="must be positive"):
+        bootstrap_session(df=-1)
+
+
+def test_compliant_with_as_clause():
+    with pytest.raises(ValueError) as exc_info:
+        bootstrap_session(df=-1)
+    assert "df must be positive" in str(exc_info.value)
+
+
+def test_compliant_imported_raises():
+    with imported_raises(ValueError):
+        process_data(123)
+
+
+def test_noncompliant_imported_raises_deprecated():
+    imported_raises(ValueError, bootstrap_session, df=-1)  # Noncompliant {{Prefer the context manager form: wrap the raising code in "with pytest.raises(...)".}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_non_pytest_call():
+    process_data('hello')
+
+
+def test_compliant_parenthesized_with_block():
+    with (pytest.raises(ValueError)):
+        process_data(123)
+
+
+def test_noncompliant_standalone_parenthesized_raises():
+    (pytest.raises(ValueError))  # Noncompliant {{Prefer the context manager form: wrap the raising code in "with pytest.raises(...)".}}
+#    ^^^^^^^^^^^^^^^^^^^^^^^^^
+    process_data('hello')
+
+
+def test_compliant_saved_raises_reused_in_with():
+    ctx = pytest.raises(ValueError)
+    with ctx:
+        process_data(123)
+
+
+def test_compliant_saved_raises_reused_in_with_as():
+    raises = pytest.raises(ValueError, match="must be positive")
+    with raises as exc_info:
+        bootstrap_session(df=-1)
+    assert "df must be positive" in str(exc_info.value)
+
+
+def test_compliant_saved_raises_conditional_then_with():
+    if True:
+        ctx = pytest.raises(TypeError, match="Invalid value")
+    else:
+        ctx = contextlib.nullcontext()
+    with ctx:
+        process_data(123)
+
+
+def test_compliant_ternary_assignment_used_in_with(descr, fields, expected):
+    # Production FP: assigned via ternary, later used as context manager.
+    context = contextlib.nullcontext() if isinstance(expected, dict) else pytest.raises(expected)
+    with context:
+        result = process_data(fields)
+        assert result == expected, descr
+
+
+def test_compliant_saved_parenthesized_raises_reused_in_with():
+    ctx = (pytest.raises(ValueError))
+    with ctx:
+        process_data(123)
+
+
+def test_compliant_annotated_assignment_reused_in_with():
+    ctx: object = pytest.raises(ValueError)
+    with ctx:
+        process_data(123)
+
+
+def test_compliant_saved_raises_never_used_in_with():
+    # Uncertain: value may escape analysis; prefer FN over FP.
+    ctx = pytest.raises(ValueError)
+    process_data('hello')
+
+
+def test_compliant_chained_assignment_used_in_with():
+    a = b = pytest.raises(ValueError)
+    with a:
+        process_data(123)
+
+
+def test_compliant_tuple_unpacking_assignment():
+    ctx, other = pytest.raises(ValueError), None
+    process_data('hello')
+
+
+def test_compliant_attribute_assignment():
+    holder = type('Holder', (), {})()
+    holder.ctx = pytest.raises(ValueError)
+    process_data('hello')
+
+
+@pytest.mark.parametrize(
+    "mode, expected_output, expectation",
+    [
+        pytest.param(
+            None,
+            "out",
+            pytest.raises(ValueError),
+            id="raises injected via pytest.param",
+        ),
+        pytest.param(
+            None,
+            "out",
+            contextlib.nullcontext(),
+            id="nullcontext",
+        ),
+    ],
+)
+def test_compliant_parametrize_pytest_param_raises_used_in_with(mode, expected_output, expectation):
+    with expectation:
+        process_data(123)
+
+
+@pytest.mark.parametrize(
+    "expectation",
+    [pytest.raises(ValueError)],
+)
+def test_compliant_parametrize_direct_raises_used_in_with(expectation):
+    with expectation:
+        process_data(123)
+
+
+@pytest.mark.parametrize(
+    "x, expectation",
+    [(1, pytest.raises(ValueError))],
+)
+def test_compliant_parametrize_tuple_raises_used_in_with(x, expectation):
+    with expectation:
+        process_data(123)
+
+
+@pytest.mark.parametrize(
+    ["expectation"],
+    [pytest.raises(TypeError)],
+)
+def test_compliant_parametrize_list_argnames_raises_used_in_with(expectation):
+    with expectation:
+        process_data(123)
+
+
+@pytest.mark.parametrize(
+    "expectation",
+    [pytest.raises(ValueError)],
+)
+def test_compliant_parametrize_raises_never_used_in_with(expectation):
+    # Uncertain injection usage; prefer FN over FP.
+    process_data('hello')
+
+
+@pytest.mark.parametrize(
+    "x, expectation, unused",
+    [
+        pytest.param(
+            1,
+            contextlib.nullcontext(),
+            pytest.raises(ValueError),
+        ),
+    ],
+)
+def test_compliant_parametrize_raises_not_the_with_param(x, expectation, unused):
+    with expectation:
+        process_data(123)
+
+
+def external_error_raised(expected_exception):
+    return pytest.raises(expected_exception, match=None)
+
+
+def external_error_raised_parenthesized(expected_exception):
+    return (pytest.raises(expected_exception, match=None))
+
+
+def external_error_raised_via_local(expected_exception):
+    ctx = pytest.raises(expected_exception, match=None)
+    return ctx
+
+
+_MODULE_RAISES = pytest.raises(ValueError)
+
+
+def assign_raises_to_global():
+    global _MODULE_RAISES
+    _MODULE_RAISES = pytest.raises(TypeError)
+
+
+class RaisesHolder:
+    def store_raises_on_self(self):
+        self.ctx = pytest.raises(ValueError)
+
+    def store_raises_on_self_annotated(self):
+        self.ctx: object = pytest.raises(ValueError)
+
+
+def escapes_via_argument_to_other_call(expected_exception):
+    return process_data(pytest.raises(expected_exception, match=None))
+
+
+def escapes_via_direct_call_argument(expected_exception):
+    process_data(pytest.raises(expected_exception, match=None))
+
+
+def escapes_via_local_passed_as_argument(expected_exception):
+    ctx = pytest.raises(expected_exception, match=None)
+    process_data(ctx)
diff --git a/python-checks/src/test/resources/checks/tests/pytestUselessYieldFixture.py b/python-checks/src/test/resources/checks/tests/pytestUselessYieldFixture.py
new file mode 100644
index 0000000000..54a5460390
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/pytestUselessYieldFixture.py
@@ -0,0 +1,180 @@
+import pytest
+
+
+@pytest.fixture
+def useless_yield():
+    data = load()
+    yield data  # Noncompliant {{No teardown in this fixture. Use "return" instead of "yield".}}
+#   ^^^^^^^^^^
+
+
+@pytest.fixture()
+def useless_yield_with_call():
+    resource = acquire()
+    yield resource  # Noncompliant {{No teardown in this fixture. Use "return" instead of "yield".}}
+#   ^^^^^^^^^^^^^^
+
+
+@pytest.fixture
+def bare_yield_only():
+    yield  # Noncompliant {{Remove this useless "yield".}}
+#   ^^^^^
+
+
+@pytest.fixture(autouse=True)
+def clear_db():
+    clear_db_logs()
+    clear_db_runs()
+    clear_db_dags()
+    yield  # Noncompliant {{Remove this useless "yield".}}
+#   ^^^^^
+
+
+@pytest.fixture
+def only_yield_value():
+    yield 42  # Noncompliant {{No teardown in this fixture. Use "return" instead of "yield".}}
+#   ^^^^^^^^
+
+
+from pytest import fixture
+
+
+@fixture
+def imported_fixture():
+    yield load()  # Noncompliant {{No teardown in this fixture. Use "return" instead of "yield".}}
+#   ^^^^^^^^^^^^
+
+
+from pytest import fixture as pytest_fixture
+
+
+@pytest_fixture
+def aliased_fixture():
+    value = setup()
+    yield value  # Noncompliant {{No teardown in this fixture. Use "return" instead of "yield".}}
+#   ^^^^^^^^^^^
+
+
+@pytest.fixture(scope="module")
+def scoped_useless_yield():
+    yield create()  # Noncompliant {{No teardown in this fixture. Use "return" instead of "yield".}}
+#   ^^^^^^^^^^^^^^
+
+
+@pytest.fixture
+def with_teardown():
+    resource = acquire()
+    yield resource
+    resource.release()
+
+
+@pytest.fixture
+def with_pass_after_yield():
+    yield 1
+    pass
+
+
+@pytest.fixture
+def bare_yield_with_teardown():
+    setup()
+    yield
+    teardown()
+
+
+@pytest.fixture
+def return_fixture():
+    return load()
+
+
+@pytest.fixture
+def return_after_setup():
+    data = load()
+    return data
+
+
+def not_a_fixture():
+    yield 1
+
+
+@pytest.fixture
+def nested_generator_ok():
+    def inner():
+        yield 1
+
+    return inner()
+
+
+@pytest.fixture
+def nested_yield_then_yield():
+    def inner():
+        yield 1
+
+    yield inner()  # Noncompliant {{No teardown in this fixture. Use "return" instead of "yield".}}
+#   ^^^^^^^^^^^^^
+
+
+@pytest.fixture
+def multiple_yields_last_is_yield():
+    # Covered by S8994; do not suggest return/remove on the last yield alone.
+    yield 1
+    yield 2
+
+
+@pytest.fixture
+def yield_in_if_not_last():
+    if cond:
+        yield 1
+    else:
+        yield 2
+
+
+@pytest.fixture
+async def async_useless_yield():
+    yield await load()  # Noncompliant {{No teardown in this fixture. Use "return" instead of "yield".}}
+#   ^^^^^^^^^^^^^^^^^^
+
+
+import unittest
+from abc import ABC, abstractmethod
+
+
+class MyTest(unittest.TestCase):
+
+    @pytest.fixture
+    def class_fixture(self):
+        yield "setup"  # Noncompliant {{No teardown in this fixture. Use "return" instead of "yield".}}
+#       ^^^^^^^^^^^^^
+
+    @pytest.fixture
+    def class_fixture_with_teardown(self):
+        yield "setup"
+        self.cleanup()
+
+
+class AbstractFixtures(ABC):
+
+    @pytest.fixture
+    @abstractmethod
+    def abstract_fixture(self):
+        yield 1
+
+
+def _restore_logging():
+    handlers = []
+    try:
+        yield
+    finally:
+        pass
+
+
+@pytest.fixture
+def restore_logging_via_yield_from():
+    yield from _restore_logging()
+
+
+@pytest.fixture
+def useless_yield_from_without_teardown():
+    def values():
+        yield 1
+
+    yield from values()
diff --git a/python-checks/src/test/resources/checks/tests/singleInvocationRuntimeException.py b/python-checks/src/test/resources/checks/tests/singleInvocationRuntimeException.py
new file mode 100644
index 0000000000..a79274aaf7
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/singleInvocationRuntimeException.py
@@ -0,0 +1,406 @@
+import copy
+import unittest
+import uuid
+from pathlib import Path
+from uuid import UUID, uuid4
+
+import numpy as np
+import pytest
+from numpy import eye, identity, ones, zeros
+from numpy.polynomial.legendre import legval
+from scipy.special import legendre
+
+
+def get_item():
+    return Item()
+
+
+def do_work(value=None):
+    raise ValueError(value)
+
+
+class Item:
+    def process(self):
+        raise ValueError()
+
+
+class DummyContextManager:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+
+def test_pytest_with_call_chain():
+    with pytest.raises(ValueError):  # Noncompliant {{Refactor this exception test to have only one invocation possibly throwing an exception.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        get_item().process()
+#       ^^^^^^^^^^< {{Invocation possibly throwing an exception.}}
+#                  ^^^^^^^^^@-1< {{Invocation possibly throwing an exception.}}
+
+
+def test_pytest_with_nested_calls():
+    with pytest.raises(ValueError):  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        do_work(get_item())
+#       ^^^^^^^^^^^^^^^^^^^< {{Invocation possibly throwing an exception.}}
+#               ^^^^^^^^^^@-1< {{Invocation possibly throwing an exception.}}
+
+
+def test_pytest_with_single_invocation():
+    item = get_item()
+    with pytest.raises(ValueError):
+        item.process()
+
+
+def test_pytest_with_safe_builtins():
+    with pytest.raises(ValueError):
+        do_work(str())
+
+
+def test_pytest_with_safe_list():
+    with pytest.raises(ValueError):
+        do_work(list())
+
+
+def test_pytest_with_safe_set():
+    with pytest.raises(ValueError):
+        do_work(set())
+
+
+def test_pytest_with_safe_dict():
+    with pytest.raises(ValueError):
+        do_work(dict())
+
+
+def test_pytest_with_safe_tuple():
+    with pytest.raises(ValueError):
+        do_work(tuple())
+
+
+def test_pytest_with_safe_frozenset():
+    with pytest.raises(ValueError):
+        do_work(frozenset())
+
+
+def test_pytest_with_safe_bytes():
+    with pytest.raises(ValueError):
+        do_work(bytes())
+
+
+def test_pytest_with_safe_bytearray():
+    with pytest.raises(ValueError):
+        do_work(bytearray())
+
+
+def test_pytest_with_safe_object():
+    with pytest.raises(ValueError):
+        do_work(object())
+
+
+def test_pytest_with_unsafe_builtin_arguments():
+    with pytest.raises(ValueError):  # Noncompliant {{Refactor this exception test to have only one invocation possibly throwing an exception.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        do_work(object(1))
+#       ^^^^^^^^^^^^^^^^^^< {{Invocation possibly throwing an exception.}}
+#               ^^^^^^^^^@-1< {{Invocation possibly throwing an exception.}}
+
+
+def test_pytest_with_unsafe_collection_arguments():
+    with pytest.raises(ValueError):  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        do_work(set(5))
+#       ^^^^^^^^^^^^^^^< {{Invocation possibly throwing an exception.}}
+#               ^^^^^^@-1< {{Invocation possibly throwing an exception.}}
+
+
+def test_pytest_with_dict_named_args():
+    with pytest.raises(ValueError):
+        do_work(dict(x=1))
+
+
+def test_pytest_with_str_argument():
+    with pytest.raises(ValueError):
+        do_work(str(1))
+
+
+def test_pytest_with_print():
+    with pytest.raises(ValueError):
+        print(do_work())
+
+
+def test_pytest_with_path():
+    with pytest.raises(ValueError):
+        do_work(Path("missing"))
+
+
+def test_pytest_with_uuid4():
+    with pytest.raises(ValueError):
+        do_work(uuid4())
+
+
+def test_pytest_with_uuid_module():
+    with pytest.raises(ValueError):
+        do_work(uuid.uuid4())
+
+
+def test_pytest_with_uuid_constructor():
+    with pytest.raises(ValueError):
+        do_work(UUID(int=0))
+
+
+def test_pytest_with_numpy_zeros():
+    with pytest.raises(ValueError):
+        do_work(np.zeros(3))
+
+
+def test_pytest_with_numpy_ones():
+    with pytest.raises(ValueError):
+        do_work(ones((2, 2)))
+
+
+def test_pytest_with_numpy_identity():
+    with pytest.raises(ValueError):
+        do_work(identity(3))
+
+
+def test_pytest_with_numpy_eye():
+    with pytest.raises(ValueError):
+        do_work(eye(3))
+
+
+def test_pytest_with_numpy_empty():
+    with pytest.raises(ValueError):
+        do_work(np.empty(2))
+
+
+def test_pytest_with_numpy_full():
+    with pytest.raises(ValueError):
+        do_work(np.full(2, 0))
+
+
+def test_pytest_with_numpy_zeros_like():
+    with pytest.raises(ValueError):
+        do_work(np.zeros_like([1, 2]))
+
+
+def test_pytest_with_numpy_ones_like():
+    with pytest.raises(ValueError):
+        do_work(np.ones_like([1, 2]))
+
+
+def test_pytest_with_numpy_empty_like():
+    with pytest.raises(ValueError):
+        do_work(np.empty_like([1, 2]))
+
+
+def test_pytest_with_numpy_full_like():
+    with pytest.raises(ValueError):
+        do_work(np.full_like([1, 2], 0))
+
+
+def test_pytest_with_numpy_array():
+    with pytest.raises(ValueError):
+        do_work(np.array([1, 2]))
+
+
+def test_pytest_with_numpy_asarray():
+    with pytest.raises(ValueError):
+        do_work(np.asarray([1, 2]))
+
+
+def test_pytest_with_numpy_arange():
+    with pytest.raises(ValueError):
+        do_work(np.arange(3))
+
+
+def test_pytest_with_numpy_linspace():
+    with pytest.raises(ValueError):
+        do_work(np.linspace(0, 1, 5))
+
+
+def test_pytest_with_numpy_random_randn():
+    with pytest.raises(ValueError):
+        do_work(np.random.randn(2, 2))
+
+
+def test_pytest_with_numpy_random_random():
+    with pytest.raises(ValueError):
+        do_work(np.random.random((2, 2)))
+
+
+def test_pytest_with_numpy_random_rand():
+    with pytest.raises(ValueError):
+        do_work(np.random.rand(2, 2))
+
+
+def test_pytest_with_numpy_random_randint():
+    with pytest.raises(ValueError):
+        do_work(np.random.randint(0, 10, size=3))
+
+
+def test_pytest_with_numpy_random_default_rng():
+    with pytest.raises(ValueError):
+        do_work(np.random.default_rng(0))
+
+
+def test_pytest_with_numpy_random_state():
+    with pytest.raises(ValueError):
+        do_work(np.random.RandomState(0))
+
+
+def test_pytest_with_numpy_copy():
+    with pytest.raises(ValueError):
+        do_work(np.copy([1, 2]))
+
+
+def test_pytest_with_numpy_legendre():
+    with pytest.raises(ValueError):
+        do_work(legval(0.5, [1, 0, 1]))
+
+
+def test_pytest_with_scipy_legendre():
+    with pytest.raises(ValueError):
+        do_work(legendre(3))
+
+
+def test_pytest_with_copy_copy():
+    with pytest.raises(ValueError):
+        do_work(copy.copy([1, 2]))
+
+
+def test_pytest_with_copy_deepcopy():
+    with pytest.raises(ValueError):
+        do_work(copy.deepcopy([1, 2]))
+
+
+def test_pytest_direct_lambda_with_numpy_zeros():
+    pytest.raises(ValueError, lambda: do_work(zeros(3)))
+
+
+def test_pytest_with_len_and_repr():
+    with pytest.raises(ValueError):
+        do_work(len(repr(1)))
+
+
+def test_pytest_with_list_and_tuple_args():
+    with pytest.raises(ValueError):
+        do_work(list((1,)))
+
+
+def test_pytest_direct_lambda():
+    pytest.raises(ValueError, lambda: get_item().process())  # Noncompliant {{Refactor this exception test to have only one invocation possibly throwing an exception.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                                     ^^^^^^^^^^@-1< {{Invocation possibly throwing an exception.}}
+#                                                ^^^^^^^^^@-2< {{Invocation possibly throwing an exception.}}
+
+
+def test_pytest_direct_callable():
+    item = get_item()
+    pytest.raises(ValueError, item.process)
+
+
+def test_pytest_direct_lambda_with_safe_builtin():
+    pytest.raises(ValueError, lambda: do_work(str()))
+
+
+def test_pytest_direct_lambda_single_invocation():
+    pytest.raises(ValueError, lambda: do_work())
+
+
+def test_pytest_direct_lambda_with_dict_positional_argument():
+    pytest.raises(ValueError, lambda: do_work(dict(5)))
+
+
+def test_pytest_direct_lambda_with_dict_named_args():
+    pytest.raises(ValueError, lambda: do_work(dict(x=1)))
+
+
+def test_pytest_direct_lambda_with_uuid():
+    pytest.raises(ValueError, lambda: do_work(uuid4()))
+
+
+def test_non_raise_with_statement():
+    with DummyContextManager():
+        get_item().process()
+
+
+def test_pytest_with_nested_lambda_definition():
+    with pytest.raises(ValueError):
+        do_work(lambda value: get_item().process())
+
+
+def test_pytest_with_nested_helper_definition():
+    with pytest.raises(ValueError):
+        def helper():
+            return get_item().process()
+        do_work()
+
+
+class TestCase(unittest.TestCase):
+    def test_unittest_with_statement(self):
+        with self.assertRaises(ValueError):  # Noncompliant {{Refactor this exception test to have only one invocation possibly throwing an exception.}}
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+            get_item().process()
+#           ^^^^^^^^^^< {{Invocation possibly throwing an exception.}}
+#                      ^^^^^^^^^@-1< {{Invocation possibly throwing an exception.}}
+
+    def test_unittest_with_safe_builtin(self):
+        with self.assertRaises(ValueError):
+            do_work(dict())
+
+    def test_unittest_with_dict_named_args(self):
+        with self.assertRaises(ValueError):
+            do_work(dict(x=1))
+
+    def test_unittest_with_path_and_str(self):
+        with self.assertRaises(ValueError):
+            do_work(str(Path("x")))
+
+    def test_unittest_with_uuid(self):
+        with self.assertRaises(ValueError):
+            do_work(uuid.uuid4())
+
+    def test_unittest_with_numpy_zeros(self):
+        with self.assertRaises(ValueError):
+            do_work(np.zeros(3))
+
+    def test_unittest_lambda_with_numpy_ones(self):
+        self.assertRaises(ValueError, lambda: do_work(ones(3)))
+
+    def test_unittest_lambda(self):
+        self.assertRaises(ValueError, lambda: get_item().process())  # Noncompliant {{Refactor this exception test to have only one invocation possibly throwing an exception.}}
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                                             ^^^^^^^^^^@-1< {{Invocation possibly throwing an exception.}}
+#                                                        ^^^^^^^^^@-2< {{Invocation possibly throwing an exception.}}
+
+    def test_unittest_lambda_nested_calls(self):
+        self.assertRaises(ValueError, lambda: do_work(get_item()))  # Noncompliant
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                                             ^^^^^^^^^^^^^^^^^^^@-1< {{Invocation possibly throwing an exception.}}
+#                                                     ^^^^^^^^^^@-2< {{Invocation possibly throwing an exception.}}
+
+    def test_unittest_lambda_with_safe_builtin(self):
+        self.assertRaises(ValueError, lambda: do_work(bytearray()))
+
+    def test_unittest_bound_method(self):
+        item = get_item()
+        self.assertRaises(ValueError, item.process)
+
+    def test_unittest_lambda_single_invocation(self):
+        self.assertRaises(ValueError, lambda: do_work())
+
+    def test_unittest_lambda_with_unsafe_builtin_argument(self):
+        self.assertRaises(ValueError, lambda: do_work(frozenset(5)))  # Noncompliant
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                                             ^^^^^^^^^^^^^^^^^^^^^@-1< {{Invocation possibly throwing an exception.}}
+#                                                     ^^^^^^^^^^^^@-2< {{Invocation possibly throwing an exception.}}
+
+    def test_unittest_invalid_raise_method(self):
+        self.assertRaisesRandom(ValueError, lambda: do_work(get_item()))
+
+
+class Helper:
+    def test_not_a_unittest_test_case(self):
+        self.assertRaises(ValueError, lambda: do_work(get_item()))
diff --git a/python-checks/src/test/resources/checks/tests/singleInvocationWarning.py b/python-checks/src/test/resources/checks/tests/singleInvocationWarning.py
new file mode 100644
index 0000000000..6e6bfbb660
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/singleInvocationWarning.py
@@ -0,0 +1,335 @@
+import copy
+import uuid
+import warnings
+from pathlib import Path
+from uuid import UUID, uuid4
+
+import numpy as np
+import pytest
+from numpy import eye, identity, ones, zeros
+from numpy.polynomial.legendre import legval
+from scipy.special import legendre
+
+
+def get_item():
+    return Item()
+
+
+def setup():
+    pass
+
+
+def do_work(value=None):
+    warnings.warn("x", UserWarning)
+
+
+class Item:
+    def process(self):
+        warnings.warn("x", UserWarning)
+
+
+class DummyContextManager:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+
+def test_pytest_with_call_chain():
+    with pytest.warns(UserWarning):  # Noncompliant {{Refactor this warning test to have only one invocation possibly emitting a warning.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        get_item().process()
+#       ^^^^^^^^^^< {{Invocation possibly emitting a warning.}}
+#                  ^^^^^^^^^@-1< {{Invocation possibly emitting a warning.}}
+
+
+def test_pytest_with_nested_calls():
+    with pytest.warns(UserWarning):  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        do_work(get_item())
+#       ^^^^^^^^^^^^^^^^^^^< {{Invocation possibly emitting a warning.}}
+#               ^^^^^^^^^^@-1< {{Invocation possibly emitting a warning.}}
+
+
+def test_pytest_with_multiple_statements():
+    with pytest.warns(UserWarning):  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        setup()
+#       ^^^^^^^< {{Invocation possibly emitting a warning.}}
+        warnings.warn("x", UserWarning)
+#                ^^^^^^^^^^^^^^^^^^^^^^< {{Invocation possibly emitting a warning.}}
+
+
+def test_pytest_with_single_invocation():
+    item = get_item()
+    with pytest.warns(UserWarning):
+        item.process()
+
+
+def test_pytest_setup_outside():
+    setup()
+    with pytest.warns(UserWarning):
+        warnings.warn("x", UserWarning)
+
+
+def test_pytest_with_safe_builtins():
+    with pytest.warns(UserWarning):
+        do_work(str())
+
+
+def test_pytest_with_safe_list():
+    with pytest.warns(UserWarning):
+        do_work(list())
+
+
+def test_pytest_with_safe_set():
+    with pytest.warns(UserWarning):
+        do_work(set())
+
+
+def test_pytest_with_safe_dict():
+    with pytest.warns(UserWarning):
+        do_work(dict())
+
+
+def test_pytest_with_safe_tuple():
+    with pytest.warns(UserWarning):
+        do_work(tuple())
+
+
+def test_pytest_with_safe_frozenset():
+    with pytest.warns(UserWarning):
+        do_work(frozenset())
+
+
+def test_pytest_with_safe_bytes():
+    with pytest.warns(UserWarning):
+        do_work(bytes())
+
+
+def test_pytest_with_safe_bytearray():
+    with pytest.warns(UserWarning):
+        do_work(bytearray())
+
+
+def test_pytest_with_safe_object():
+    with pytest.warns(UserWarning):
+        do_work(object())
+
+
+def test_pytest_with_unsafe_builtin_arguments():
+    with pytest.warns(UserWarning):  # Noncompliant {{Refactor this warning test to have only one invocation possibly emitting a warning.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        do_work(object(1))
+#       ^^^^^^^^^^^^^^^^^^< {{Invocation possibly emitting a warning.}}
+#               ^^^^^^^^^@-1< {{Invocation possibly emitting a warning.}}
+
+
+def test_pytest_with_unsafe_collection_arguments():
+    with pytest.warns(UserWarning):  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        do_work(set(5))
+#       ^^^^^^^^^^^^^^^< {{Invocation possibly emitting a warning.}}
+#               ^^^^^^@-1< {{Invocation possibly emitting a warning.}}
+
+
+def test_pytest_with_dict_named_args():
+    with pytest.warns(UserWarning):
+        do_work(dict(x=1))
+
+
+def test_pytest_with_str_argument():
+    with pytest.warns(UserWarning):
+        do_work(str(1))
+
+
+def test_pytest_with_print():
+    with pytest.warns(UserWarning):
+        print(do_work())
+
+
+def test_pytest_with_path():
+    with pytest.warns(UserWarning):
+        do_work(Path("missing"))
+
+
+def test_pytest_with_uuid4():
+    with pytest.warns(UserWarning):
+        do_work(uuid4())
+
+
+def test_pytest_with_uuid_module():
+    with pytest.warns(UserWarning):
+        do_work(uuid.uuid4())
+
+
+def test_pytest_with_uuid_constructor():
+    with pytest.warns(UserWarning):
+        do_work(UUID(int=0))
+
+
+def test_pytest_with_numpy_zeros():
+    with pytest.warns(UserWarning):
+        do_work(np.zeros(3))
+
+
+def test_pytest_with_numpy_ones():
+    with pytest.warns(UserWarning):
+        do_work(ones((2, 2)))
+
+
+def test_pytest_with_numpy_identity():
+    with pytest.warns(UserWarning):
+        do_work(identity(3))
+
+
+def test_pytest_with_numpy_eye():
+    with pytest.warns(UserWarning):
+        do_work(eye(3))
+
+
+def test_pytest_with_numpy_empty():
+    with pytest.warns(UserWarning):
+        do_work(np.empty(2))
+
+
+def test_pytest_with_numpy_full():
+    with pytest.warns(UserWarning):
+        do_work(np.full(2, 0))
+
+
+def test_pytest_with_numpy_zeros_like():
+    with pytest.warns(UserWarning):
+        do_work(np.zeros_like([1, 2]))
+
+
+def test_pytest_with_numpy_ones_like():
+    with pytest.warns(UserWarning):
+        do_work(np.ones_like([1, 2]))
+
+
+def test_pytest_with_numpy_empty_like():
+    with pytest.warns(UserWarning):
+        do_work(np.empty_like([1, 2]))
+
+
+def test_pytest_with_numpy_full_like():
+    with pytest.warns(UserWarning):
+        do_work(np.full_like([1, 2], 0))
+
+
+def test_pytest_with_numpy_array():
+    with pytest.warns(UserWarning):
+        do_work(np.array([1, 2]))
+
+
+def test_pytest_with_numpy_asarray():
+    with pytest.warns(UserWarning):
+        do_work(np.asarray([1, 2]))
+
+
+def test_pytest_with_numpy_arange():
+    with pytest.warns(UserWarning):
+        do_work(np.arange(3))
+
+
+def test_pytest_with_numpy_linspace():
+    with pytest.warns(UserWarning):
+        do_work(np.linspace(0, 1, 5))
+
+
+def test_pytest_with_numpy_random_randn():
+    with pytest.warns(UserWarning):
+        do_work(np.random.randn(2, 2))
+
+
+def test_pytest_with_numpy_random_random():
+    with pytest.warns(UserWarning):
+        do_work(np.random.random((2, 2)))
+
+
+def test_pytest_with_numpy_random_rand():
+    with pytest.warns(UserWarning):
+        do_work(np.random.rand(2, 2))
+
+
+def test_pytest_with_numpy_random_randint():
+    with pytest.warns(UserWarning):
+        do_work(np.random.randint(0, 10, size=3))
+
+
+def test_pytest_with_numpy_random_default_rng():
+    with pytest.warns(UserWarning):
+        do_work(np.random.default_rng(0))
+
+
+def test_pytest_with_numpy_random_state():
+    with pytest.warns(UserWarning):
+        do_work(np.random.RandomState(0))
+
+
+def test_pytest_with_numpy_copy():
+    with pytest.warns(UserWarning):
+        do_work(np.copy([1, 2]))
+
+
+def test_pytest_with_numpy_legendre():
+    with pytest.warns(UserWarning):
+        do_work(legval(0.5, [1, 0, 1]))
+
+
+def test_pytest_with_scipy_legendre():
+    with pytest.warns(UserWarning):
+        do_work(legendre(3))
+
+
+def test_pytest_with_copy_copy():
+    with pytest.warns(UserWarning):
+        do_work(copy.copy([1, 2]))
+
+
+def test_pytest_with_copy_deepcopy():
+    with pytest.warns(UserWarning):
+        do_work(copy.deepcopy([1, 2]))
+
+
+def test_pytest_with_len_and_repr():
+    with pytest.warns(UserWarning):
+        do_work(len(repr(1)))
+
+
+def test_pytest_with_list_and_tuple_args():
+    with pytest.warns(UserWarning):
+        do_work(list((1,)))
+
+
+def test_non_warns_with_statement():
+    with DummyContextManager():
+        get_item().process()
+
+
+def test_pytest_raises_is_out_of_scope():
+    with pytest.raises(ValueError):
+        get_item().process()
+
+
+def test_pytest_with_nested_lambda_definition():
+    with pytest.warns(UserWarning):
+        do_work(lambda value: get_item().process())
+
+
+def test_pytest_with_nested_helper_definition():
+    with pytest.warns(UserWarning):
+        def helper():
+            return get_item().process()
+        do_work()
+
+
+def test_pytest_warns_from_import():
+    from pytest import warns
+    with warns(UserWarning):  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^
+        get_item().process()
+#       ^^^^^^^^^^< {{Invocation possibly emitting a warning.}}
+#                  ^^^^^^^^^@-1< {{Invocation possibly emitting a warning.}}
diff --git a/python-checks/src/test/resources/checks/tests/specificExceptionAssertion.py b/python-checks/src/test/resources/checks/tests/specificExceptionAssertion.py
new file mode 100644
index 0000000000..166a8cae10
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/specificExceptionAssertion.py
@@ -0,0 +1,141 @@
+import unittest
+
+import pytest
+from pytest import raises as imported_raises
+
+
+def explode():
+    raise ValueError("bad value")
+
+
+class CustomException(Exception):
+    pass
+
+
+def raise_custom_exception():
+    raise CustomException("custom")
+
+
+class DummyContextManager:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return False
+
+
+dummy_context_manager = DummyContextManager()
+
+
+def test_pytest_raises_exception():
+    with pytest.raises(Exception):  # Noncompliant {{This assertion is too broad; use a more specific exception type or check the exception message.}}
+#                      ^^^^^^^^^
+        explode()
+
+
+def test_pytest_raises_base_exception():
+    with pytest.raises(BaseException):  # Noncompliant {{This assertion is too broad; use a more specific exception type or check the exception message.}}
+#                      ^^^^^^^^^^^^^
+        explode()
+
+
+def test_pytest_raises_expected_exception_keyword():
+    with pytest.raises(expected_exception=Exception):  # Noncompliant {{This assertion is too broad; use a more specific exception type or check the exception message.}}
+#                                         ^^^^^^^^^
+        explode()
+
+
+def test_pytest_imported_raises():
+    with imported_raises(Exception):  # Noncompliant {{This assertion is too broad; use a more specific exception type or check the exception message.}}
+#                        ^^^^^^^^^
+        explode()
+
+
+def test_pytest_raises_specific_exception():
+    with pytest.raises(ValueError):
+        explode()
+
+
+def test_pytest_raises_custom_exception():
+    with pytest.raises(CustomException):
+        raise_custom_exception()
+
+
+def test_pytest_raises_generic_exception_with_match():
+    with pytest.raises(Exception, match="bad value"):
+        explode()
+
+
+def test_pytest_direct_raises_exception():
+    pytest.raises(Exception, explode)  # Noncompliant {{This assertion is too broad; use a more specific exception type or check the exception message.}}
+#                 ^^^^^^^^^
+
+
+def test_pytest_direct_imported_raises_exception():
+    imported_raises(BaseException, explode)  # Noncompliant {{This assertion is too broad; use a more specific exception type or check the exception message.}}
+#                   ^^^^^^^^^^^^^
+
+
+def test_with_non_call_context_manager():
+    with dummy_context_manager:
+        explode()
+
+
+def test_raise_qualifier_named_helper_parameter(helper):
+    with helper.assertRaises(Exception):
+        explode()
+
+
+def test_raise_qualifier_named_cls_parameter(cls):
+    with cls.assertRaises(Exception):
+        explode()
+
+
+class MyTest(unittest.TestCase):
+    def test_unittest_assert_raises_exception(self):
+        with self.assertRaises(Exception):  # Noncompliant {{This assertion is too broad; use a more specific exception type or check the exception message.}}
+#                              ^^^^^^^^^
+            explode()
+
+    def test_unittest_assert_raises_base_exception(self):
+        with self.assertRaises(BaseException):  # Noncompliant {{This assertion is too broad; use a more specific exception type or check the exception message.}}
+#                              ^^^^^^^^^^^^^
+            explode()
+
+    def test_unittest_assert_raises_regex_exception(self):
+        with self.assertRaisesRegex(Exception, "bad"):
+            explode()
+
+    def test_unittest_assert_raises_regexp_exception(self):
+        with self.assertRaisesRegexp(Exception, "bad"):
+            explode()
+
+    def test_unittest_assert_raises_keyword_exception(self):
+        with self.assertRaisesRegex(exception=Exception, regex="bad"):
+            explode()
+
+    def test_unittest_assert_raises_specific_exception(self):
+        with self.assertRaisesRegex(ValueError, "bad value"):
+            explode()
+
+    def test_unittest_assert_raises_custom_exception(self):
+        with self.assertRaises(CustomException):
+            raise_custom_exception()
+
+    def test_unittest_direct_assert_raises_exception(self):
+        self.assertRaises(Exception, explode)  # Noncompliant {{This assertion is too broad; use a more specific exception type or check the exception message.}}
+#                         ^^^^^^^^^
+
+    def test_unittest_direct_assert_raises_regex_exception(self):
+        self.assertRaisesRegex(Exception, "bad", explode)
+
+    def test_unittest_direct_assert_raises_specific_exception(self):
+        self.assertRaises(ValueError, explode)
+
+    def test_unittest_raise_qualifier_not_self(self):
+        with helper.assertRaises(Exception):
+            explode()
+
+    def test_unittest_raise_qualifier_not_a_name(self):
+        with helper().assertRaises(Exception):
+            explode()
diff --git a/python-checks/src/test/resources/checks/tests/specificWarningAssertion.py b/python-checks/src/test/resources/checks/tests/specificWarningAssertion.py
new file mode 100644
index 0000000000..a45e009577
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/specificWarningAssertion.py
@@ -0,0 +1,159 @@
+import warnings
+
+import pytest
+from pytest import warns as imported_warns
+
+
+def emit_user_warning():
+    warnings.warn("x", UserWarning)
+
+
+def emit_deprecation_warning():
+    warnings.warn("deprecated", DeprecationWarning)
+
+
+class DummyContextManager:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return False
+
+
+dummy_context_manager = DummyContextManager()
+
+
+def test_warns_without_type():
+    with pytest.warns():  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#        ^^^^^^^^^^^^^^
+        emit_user_warning()
+
+
+def test_warns_broad_warning():
+    with pytest.warns(Warning):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#                     ^^^^^^^
+        emit_deprecation_warning()
+
+
+def test_warns_expected_warning_keyword():
+    with pytest.warns(expected_warning=Warning):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#                                      ^^^^^^^
+        emit_deprecation_warning()
+
+
+def test_imported_warns_broad():
+    with imported_warns(Warning):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#                       ^^^^^^^
+        emit_deprecation_warning()
+
+
+def test_warns_empty_match():
+    with pytest.warns(Warning, match=""):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#                     ^^^^^^^
+        emit_deprecation_warning()
+
+
+def test_warns_none_match():
+    with pytest.warns(Warning, match=None):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#                     ^^^^^^^
+        emit_deprecation_warning()
+
+
+def test_direct_warns_without_type():
+    pytest.warns()  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#   ^^^^^^^^^^^^^^
+
+
+def test_direct_warns_broad():
+    pytest.warns(Warning, emit_deprecation_warning)  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#                ^^^^^^^
+
+
+def test_warns_tuple_containing_warning():
+    with pytest.warns((Warning, UserWarning)):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#                      ^^^^^^^
+        emit_user_warning()
+
+
+def test_warns_list_containing_warning():
+    with pytest.warns([Warning, DeprecationWarning]):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#                      ^^^^^^^
+        emit_deprecation_warning()
+
+
+def test_warns_nested_tuple_containing_warning():
+    with pytest.warns(((Warning,), UserWarning)):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#                       ^^^^^^^
+        emit_user_warning()
+
+
+def test_warns_user_warning_without_match():
+    with pytest.warns(UserWarning):
+        emit_user_warning()
+
+
+def test_warns_deprecation_warning_without_match():
+    with pytest.warns(DeprecationWarning):
+        emit_deprecation_warning()
+
+
+def test_warns_specific_type():
+    with pytest.warns(ResourceWarning):
+        warnings.warn("resource", ResourceWarning)
+
+
+def test_warns_tuple_without_warning():
+    with pytest.warns((UserWarning, DeprecationWarning)):
+        emit_user_warning()
+
+
+def test_warns_tuple_with_warning_and_match():
+    with pytest.warns((Warning, UserWarning), match="x"):
+        emit_user_warning()
+
+
+def test_warns_broad_with_match():
+    with pytest.warns(Warning, match="deprecated"):
+        emit_deprecation_warning()
+
+
+def test_warns_match_only():
+    with pytest.warns(match="x"):
+        emit_user_warning()
+
+
+def test_warns_match_only_variable():
+    warning_message = "Can't encode more than one header value for the same key."
+    with pytest.warns(match=warning_message):
+        emit_user_warning()
+
+
+def test_warns_match_only_empty():
+    with pytest.warns(match=""):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#        ^^^^^^^^^^^^^^^^^^^^^^
+        emit_user_warning()
+
+
+def test_warns_match_only_none():
+    with pytest.warns(match=None):  # Noncompliant {{This assertion is too broad; use a more specific warning type or check the warning message.}}
+#        ^^^^^^^^^^^^^^^^^^^^^^^^
+        emit_user_warning()
+
+
+def test_warns_user_warning_with_match():
+    with pytest.warns(UserWarning, match="x"):
+        emit_user_warning()
+
+
+def test_imported_warns_specific():
+    with imported_warns(ResourceWarning):
+        warnings.warn("resource", ResourceWarning)
+
+
+def test_with_non_call_context_manager():
+    with dummy_context_manager:
+        emit_user_warning()
+
+
+def test_unrelated_call():
+    warnings.warn("x", UserWarning)
diff --git a/python-checks/src/test/resources/checks/tests/testCasesShouldContainTests_test.py b/python-checks/src/test/resources/checks/tests/testCasesShouldContainTests_test.py
new file mode 100644
index 0000000000..28dd8223e4
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/testCasesShouldContainTests_test.py
@@ -0,0 +1,247 @@
+import unittest
+import pytest
+
+
+def test_module_level_test():
+    assert True
+
+
+class TestPytestWithoutTests:  # Noncompliant {{Add some tests to this class.}}
+#     ^^^^^^^^^^^^^^^^^^^^^^
+    @pytest.fixture
+    def setup_data(self):
+        return 42
+
+
+class TestPytestWithTest:
+    def test_ok(self):
+        assert True
+
+
+class TestPytestEndpoint:
+    @pytest.fixture(autouse=True)
+    def setup_attrs(self):
+        self.value = 42
+
+    def teardown_method(self):
+        self.value = None
+
+
+class TestPytestDeleteEndpoint(TestPytestEndpoint):
+    def test_ok(self):
+        assert self.value == 42
+
+
+class TestPytestXunitOnly:
+    def teardown_method(self):
+        self.value = None
+
+
+class TestPytestXunitChild(TestPytestXunitOnly):
+    def test_ok(self):
+        assert True
+
+
+class HelperPytestClass:
+    def helper(self):
+        return 42
+
+
+class TestPytestHelperWithInit:
+    def __init__(self):
+        self.value = 42
+
+    def helper(self):
+        return self.value
+
+
+class TestPytestHelperWithNew:
+    def __new__(cls):
+        return super().__new__(cls)
+
+    def helper(self):
+        return 42
+
+
+class TestPlugin:
+    name = "test-plugin-cli"
+
+
+class EmptyUnittestCase(unittest.TestCase):  # Noncompliant {{Add some tests to this class.}}
+#     ^^^^^^^^^^^^^^^^^
+    def helper(self):
+        return 42
+
+
+class BaseSharedTestCase(unittest.TestCase):
+    def helper(self):
+        return 42
+
+
+class HelperMixin(unittest.TestCase):
+    def helper(self):
+        return 42
+
+
+class UnittestWithTest(unittest.TestCase):
+    def test_ok(self):
+        self.assertTrue(True)
+
+
+class BaseHelperTestCase(unittest.TestCase):
+    def helper(self):
+        return 42
+
+
+class DerivedWithOwnTest(BaseHelperTestCase):
+    def test_ok(self):
+        self.assertEqual(42, self.helper())
+
+
+class BaseWithInheritedTest(unittest.TestCase):
+    def test_from_base(self):
+        self.assertTrue(True)
+
+
+class DerivedInheritingTest(BaseWithInheritedTest):
+    def helper(self):
+        return 42
+
+
+class TestBaseHelper:
+    def helper(self):
+        return 42
+
+
+class BasePytestScaffold:
+    def helper(self):
+        return 42
+
+
+class TestDerivedWithTest(TestBaseHelper):
+    def test_ok(self):
+        assert self.helper() == 42
+
+
+class TestBaseWithTest:
+    def test_from_base(self):
+        assert True
+
+
+class TestDerivedInheritingTest(TestBaseWithTest):
+    def helper(self):
+        return 42
+
+
+class BaseWithTestAttribute(unittest.TestCase):
+    test_data = True
+
+
+class DerivedWithoutRealInheritedTest(BaseWithTestAttribute):  # Noncompliant {{Add some tests to this class.}}
+#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    def helper(self):
+        return 42
+
+
+class TestingNameOnly(unittest.TestCase):
+    def testing(self):
+        return 42
+
+
+class CamelCaseTestMethod(unittest.TestCase):
+    def testSomething(self):
+        return 42
+
+
+class TestUnknownParent(UnknownParent):  # Noncompliant {{Add some tests to this class.}}
+#     ^^^^^^^^^^^^^^^^^
+    def setUp(self):
+        return 42
+
+    def helper(self):
+        return 42
+
+
+class TestWithUnknownParentAndNoLifecycle(UnknownParent):
+    def helper(self):
+        return 42
+
+
+def TestAmbiguous():
+    return 42
+
+
+class TestAmbiguous:  # Noncompliant {{Add some tests to this class.}}
+#     ^^^^^^^^^^^^^
+    def tearDown(self):
+        return 42
+
+    def helper(self):
+        return 42
+
+
+class TestAmbiguousWithoutLifecycle:
+    def helper(self):
+        return 42
+
+
+class SharedBase:
+    def test_from_base(self):
+        assert True
+
+
+class LeftBranch(SharedBase):
+    pass
+
+
+class RightBranch(SharedBase):
+    pass
+
+
+class TestDiamondInheritance(LeftBranch, RightBranch):
+    def helper(self):
+        return 42
+
+
+def FactoryBase():
+    return object
+
+
+class TestFunctionBase(FactoryBase):  # Noncompliant {{Add some tests to this class.}}
+#     ^^^^^^^^^^^^^^^^
+    def setUpClass(self):
+        return 42
+
+    def helper(self):
+        return 42
+
+
+class TestFunctionBaseWithoutLifecycle(FactoryBase):
+    def helper(self):
+        return 42
+
+
+class SharedNoTest:
+    pass
+
+
+class LeftNoTest(SharedNoTest):
+    pass
+
+
+class RightNoTest(SharedNoTest):
+    pass
+
+
+class TestDiamondNoTests(LeftNoTest, RightNoTest):  # Noncompliant {{Add some tests to this class.}}
+#     ^^^^^^^^^^^^^^^^^^
+    def tearDownClass(self):
+        return 42
+
+    def helper(self):
+        return 42
+
+
+class TestDiamondNoTestsWithoutLifecycle(LeftNoTest, RightNoTest):
+    def helper(self):
+        return 42
diff --git a/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrder.py b/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrder.py
new file mode 100644
index 0000000000..102fac92a1
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrder.py
@@ -0,0 +1,138 @@
+import unittest
+
+import pytest
+from assertpy import assert_that
+
+EXPECTED_COUNT = 42
+EXPECTED_PI = 3.14
+
+assert 42 == value()  # OK, not inside a pytest-style test function
+assert_that(42).is_equal_to(value())  # OK, not inside a supported test function
+
+
+def value():
+    return 41 + 1
+
+
+class TestUnittestAssertions(unittest.TestCase):
+    def test_swapped_equality_arguments(self):
+        self.assertEqual(42, value())
+#       Noncompliant@-1 {{Unify assertion argument order in this file; both "actual first" and "expected first" conventions are used.}}
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^@-1
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^@-2< {{Expected value first.}}
+        self.assertEqual(first=EXPECTED_COUNT, second=value())
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+        self.assertIs(None, value())
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+        self.assertAlmostEqual(EXPECTED_PI, value())
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+
+        self.assertEqual(value(), 42)
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+        self.assertEqual(value(), value())
+        self.assertIs(value(), None)
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+        self.assertAlmostEqual(value(), EXPECTED_PI)
+#       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+        self.assertEqual(value())
+        self.assertEqual(second=EXPECTED_COUNT)
+        self.assertTrue(value())
+        helper.assertEqual(value(), 42)
+
+    def test_mutable_collection_actual_with_loop_expected(self):
+        for expected in ([3], [3, 1], [1]):
+            with self.subTest(expected=expected):
+                log = []
+                log.append(1)
+                self.assertEqual(log, expected)
+
+    def test_mutable_collection_append_before_assignment(self):
+        def f1():
+            log.append(1)
+
+        def f2():
+            log.append(2)
+
+        def f3():
+            log.append(3)
+
+        for what, expected in (
+            (f1, [1]),
+            (f2, [2]),
+            (f3, [3]),
+        ):
+            with self.subTest(what=what.__name__, expected=expected):
+                log = []
+                what()
+                self.assertEqual(log, expected)
+
+
+class Helper:
+    def test_not_a_unittest_test_case(self):
+        self.assertEqual(value(), 42)
+
+
+def test_pytest_assertions():
+    assert 42 == value()
+#          ^^^^^^^^^^^^^< {{Expected value first.}}
+    assert EXPECTED_COUNT == value()
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+    assert pytest.approx(EXPECTED_PI) == value()
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+
+    assert value() == 42
+#          ^^^^^^^^^^^^^< {{Actual value first.}}
+    assert value() == EXPECTED_COUNT
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+    assert value() == pytest.approx(EXPECTED_PI)
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+    assert value() == value()
+    assert 42 == EXPECTED_COUNT
+    assert value()
+    assert 42 != value()
+    assert 42 == pytest.approx(value())
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+    assert 42 == pytest.approx(other=value())
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+
+
+def test_assertpy_assertions():
+    assert_that(42).is_equal_to(value())
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+    assert_that(EXPECTED_COUNT).is_equal_to(value())
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+    assert_that(42).described_as("count").is_equal_to(value())
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+    assert_that(EXPECTED_COUNT).described_as("count").snapshot("baseline").is_equal_to(value())
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+
+    assert_that(value()).is_equal_to(42)
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+    assert_that(value()).is_equal_to(EXPECTED_COUNT)
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+    assert_that(value()).described_as("count").snapshot("baseline").is_equal_to(42)
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+    assert_that(value()).is_equal_to(value())
+    assert_that(42).is_equal_to(EXPECTED_COUNT)
+    assert_that(value()).is_equal_to()
+    assert_that().is_equal_to(value())
+    assert_that(value()).is_not_equal_to(42)
+    builder.is_equal_to(42)
+    factory().is_equal_to(42)
+    other_call(value()).is_equal_to(42)
+
+
+def helper_assertions():
+    assert 42 == value()
+    assert_that(42).is_equal_to(value())
+
+
+def test_mutable_collection_actual(expected):
+    result = []
+    assert result == expected
+
+
+def test_assertion_with_message(close, expected):
+    result = []
+    result.append(value())
+    assert result == expected, (close, result, expected)
diff --git a/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrderAssertpy.py b/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrderAssertpy.py
new file mode 100644
index 0000000000..a2e45df238
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrderAssertpy.py
@@ -0,0 +1,23 @@
+from assertpy import assert_that
+
+EXPECTED_COUNT = 42
+
+
+def value():
+    return 41 + 1
+
+
+# Consistent expected-first convention → no issue
+def test_assertpy_assertions_expected_first():
+    assert_that(42).is_equal_to(value())
+    assert_that(EXPECTED_COUNT).is_equal_to(value())
+    assert_that(42).described_as("count").is_equal_to(value())
+    assert_that(EXPECTED_COUNT).described_as("count").snapshot("baseline").is_equal_to(value())
+    assert_that(42).is_equal_to(EXPECTED_COUNT)
+    assert_that(value()).is_equal_to(value())
+    assert_that(value()).is_equal_to()
+    assert_that().is_equal_to(value())
+    assert_that(value()).is_not_equal_to(42)
+    builder.is_equal_to(42)
+    factory().is_equal_to(42)
+    other_call(value()).is_equal_to(42)
diff --git a/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrderExpectedLeft.py b/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrderExpectedLeft.py
new file mode 100644
index 0000000000..509f18f60f
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrderExpectedLeft.py
@@ -0,0 +1,17 @@
+import pytest
+
+EXPECTED_COUNT = 42
+EXPECTED_PI = 3.14
+
+
+def value():
+    return 41 + 1
+
+
+# Consistent actual-first convention → no issue
+def test_pytest_assertions_actual_first():
+    assert value() == 42
+    assert value() == EXPECTED_COUNT
+    assert value() == pytest.approx(EXPECTED_PI)
+    assert 42 == EXPECTED_COUNT
+    assert value() == value()
diff --git a/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrderPytest.py b/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrderPytest.py
new file mode 100644
index 0000000000..7ec07dc407
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_assertionArgumentOrderPytest.py
@@ -0,0 +1,34 @@
+import pytest
+
+EXPECTED_COUNT = 42
+EXPECTED_PI = 3.14
+
+
+def value():
+    return 41 + 1
+
+
+def test_pytest_assertions():
+    assert 42 == value()
+#   Noncompliant@-1 {{Unify assertion argument order in this file; both "actual first" and "expected first" conventions are used.}}
+#          ^^^^^^^^^^^^^@-1
+#          ^^^^^^^^^^^^^@-2< {{Expected value first.}}
+    assert EXPECTED_COUNT == value()
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+    assert pytest.approx(EXPECTED_PI) == value()
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+
+    assert value() == 42
+#          ^^^^^^^^^^^^^< {{Actual value first.}}
+    assert value() == EXPECTED_COUNT
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+    assert value() == pytest.approx(EXPECTED_PI)
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Actual value first.}}
+    assert value() == value()
+    assert 42 == EXPECTED_COUNT
+    assert value()
+    assert 42 != value()
+    assert 42 == pytest.approx(value())
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
+    assert 42 == pytest.approx(other=value())
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Expected value first.}}
diff --git a/python-checks/src/test/resources/checks/tests/test_compositeAssertion.py b/python-checks/src/test/resources/checks/tests/test_compositeAssertion.py
new file mode 100644
index 0000000000..556fa5bb8c
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_compositeAssertion.py
@@ -0,0 +1,41 @@
+import unittest
+
+
+def test_and_noncompliant(user):
+    assert user.is_active and user.is_verified  # Noncompliant {{Split this composite assertion into separate assertions.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    assert user.a and user.b and user.c  # Noncompliant
+    assert (user.is_active and user.is_verified)  # Noncompliant
+
+def test_not_or_noncompliant(axis):
+    assert not (axis.visible or axis.label_visible)  # Noncompliant
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    assert not (axis.a or axis.b or axis.c)  # Noncompliant
+
+
+def test_compliant(user, axis, a, b):
+    assert user.is_active
+    assert user.is_verified
+    assert not axis.visible
+    assert not axis.label_visible
+    assert a or b  # plain or is compliant
+    assert not a  # negated single value is compliant
+    assert not (a and b)  # negated and is compliant
+    assert a and b or b  # outer is or, compliant
+
+
+def helper_function(a, b):
+    assert a and b  # Noncompliant
+
+
+class TestCompositeAssertion(unittest.TestCase):
+    def test_and_noncompliant(self):
+        assert self.a and self.b  # Noncompliant
+
+    def test_not_or_noncompliant(self):
+        assert not (self.x or self.y)  # Noncompliant
+
+    def test_compliant(self):
+        assert self.a
+        assert self.b
+        assert self.a or self.b
diff --git a/python-checks/src/test/resources/checks/tests/test_emptyPytestModule.py b/python-checks/src/test/resources/checks/tests/test_emptyPytestModule.py
new file mode 100644
index 0000000000..4e020174c3
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_emptyPytestModule.py
@@ -0,0 +1,2 @@
+def helper_only_module():  # Noncompliant@-1 {{Add some tests to this file.}}
+    return 42
diff --git a/python-checks/src/test/resources/checks/tests/test_fileWithClassTestsButNoCandidateClass.py b/python-checks/src/test/resources/checks/tests/test_fileWithClassTestsButNoCandidateClass.py
new file mode 100644
index 0000000000..0263c2a423
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_fileWithClassTestsButNoCandidateClass.py
@@ -0,0 +1,4 @@
+class ApiTests:
+    def test_list(self):
+        assert True
+
diff --git a/python-checks/src/test/resources/checks/tests/test_groupSimilarTestsParameterized.py b/python-checks/src/test/resources/checks/tests/test_groupSimilarTestsParameterized.py
new file mode 100644
index 0000000000..f1d66243a7
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_groupSimilarTestsParameterized.py
@@ -0,0 +1,383 @@
+import unittest
+
+import pytest
+from parameterized import parameterized
+from unittest.mock import patch
+
+
+def setup_tax():
+    pass
+
+
+def get_tax(value):
+    return value
+
+
+def set_level(level):
+    pass
+
+
+def run_game():
+    pass
+
+
+def player_health():
+    return 100
+
+
+decorators = [lambda func: func]
+
+
+def test_not_null1():  # Noncompliant {{Group these similar tests into a single parameterized test.}}
+#   ^^^^^^^^^^^^^^
+    setup_tax()
+    assert get_tax(1) is not None
+
+
+def test_not_null2():
+#   ^^^^^^^^^^^^^^< {{Similar test.}}
+    setup_tax()
+    assert get_tax(2) is not None
+
+
+def test_not_null3():
+#   ^^^^^^^^^^^^^^< {{Similar test.}}
+    setup_tax()
+    assert get_tax(3) is not None
+
+
+class TestApp:
+    def test_level1(self):  # Noncompliant {{Group these similar tests into a single parameterized test.}}
+#       ^^^^^^^^^^^
+        set_level(1)
+        run_game()
+        assert player_health() == 100
+
+    def test_level2(self):
+#       ^^^^^^^^^^^< {{Similar test.}}
+        set_level(2)
+        run_game()
+        assert player_health() == 200
+
+    def test_level3(self):
+#       ^^^^^^^^^^^< {{Similar test.}}
+        set_level(3)
+        run_game()
+        assert player_health() == 300
+
+
+class TestUnittestApp(unittest.TestCase):
+    def test_user1(self):  # Noncompliant {{Group these similar tests into a single parameterized test.}}
+#       ^^^^^^^^^^
+        setup_tax()
+        self.assertIsNotNone(get_tax(1))
+
+    def test_user2(self):
+#       ^^^^^^^^^^< {{Similar test.}}
+        setup_tax()
+        self.assertIsNotNone(get_tax(2))
+
+    def test_user3(self):
+#       ^^^^^^^^^^< {{Similar test.}}
+        setup_tax()
+        self.assertIsNotNone(get_tax(3))
+
+
+@pytest.mark.parametrize("tax_id", [1, 2, 3])
+def test_already_parameterized(tax_id):
+    setup_tax()
+    assert get_tax(tax_id) is not None
+
+
+class TestParameterized(unittest.TestCase):
+    @parameterized.expand([1, 2, 3])
+    def test_parameterized(self, tax_id):
+        self.assertIsNotNone(get_tax(tax_id))
+
+
+@pytest.mark.slow
+def test_decorated_but_not_parameterized():
+    setup_tax()
+    assert get_tax(1) is not None
+
+
+def test_only_two_cases_1():
+    setup_tax()
+    assert get_tax(1) is not None
+
+
+def test_only_two_cases_2():
+    setup_tax()
+    assert get_tax(2) is not None
+
+
+def test_too_many_differences_1():
+    set_level(1)
+    run_game()
+    assert player_health() == 100
+
+
+def test_too_many_differences_2():
+    set_level(2)
+    setup_tax()
+    assert player_health() == 200
+
+
+def test_too_many_differences_3():
+    set_level(3)
+    assert get_tax(3) == 300
+
+
+@decorators[0]
+def test_non_standard_decorator_expression():
+    setup_tax()
+    assert get_tax(1) is not None
+
+
+@patch("pkg.target")
+def test_patched_tax1(mock_target):
+    setup_tax()
+    assert get_tax(1) is not None
+
+
+@patch("pkg.target")
+def test_patched_tax2(mock_target):
+    setup_tax()
+    assert get_tax(2) is not None
+
+
+@patch("pkg.target")
+def test_patched_tax3(mock_target):
+    setup_tax()
+    assert get_tax(3) is not None
+
+
+class LegacySuite(unittest.TestCase):
+    def test_legacy_user1(self):  # Noncompliant {{Group these similar tests into a single parameterized test.}}
+#       ^^^^^^^^^^^^^^^^^
+        self.assertEqual(get_tax(True), True)
+
+    def test_legacy_user2(self):
+#       ^^^^^^^^^^^^^^^^^< {{Similar test.}}
+        self.assertEqual(get_tax(False), False)
+
+    def test_legacy_user3(self):
+#       ^^^^^^^^^^^^^^^^^< {{Similar test.}}
+        self.assertEqual(get_tax(True), True)
+
+
+def test_parameter_mismatch_1(user_id):
+    setup_tax()
+    assert get_tax(user_id) is not None
+
+
+def test_parameter_mismatch_2(account_id):
+    setup_tax()
+    assert get_tax(account_id) is not None
+
+
+def test_parameter_mismatch_3(customer_id):
+    setup_tax()
+    assert get_tax(customer_id) is not None
+
+
+def test_call_with_different_arity_1():
+    assert get_tax(1) == 1
+
+
+def test_call_with_different_arity_2():
+    assert get_tax(1, 2) == 1
+
+
+def test_call_with_different_arity_3():
+    assert get_tax(1, 2, 3) == 1
+
+
+def test_non_literal_leaf_difference_1():
+    tax = 1
+    assert get_tax(tax) is not None
+
+
+def test_non_literal_leaf_difference_2():
+    value = 1
+    assert get_tax(value) is not None
+
+
+def test_non_literal_leaf_difference_3():
+    amount = 1
+    assert get_tax(amount) is not None
+
+
+def test_string_difference_1():  # Noncompliant {{Group these similar tests into a single parameterized test.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^
+    assert get_tax("alpha") is not None
+
+
+def test_string_difference_2():
+#   ^^^^^^^^^^^^^^^^^^^^^^^^< {{Similar test.}}
+    assert get_tax("beta") is not None
+
+
+def test_string_difference_3():
+#   ^^^^^^^^^^^^^^^^^^^^^^^^< {{Similar test.}}
+    assert get_tax("gamma") is not None
+
+
+def test_literal_vs_non_literal_leaf_1():
+    value = 1
+    assert get_tax(1) == value
+
+
+def test_literal_vs_non_literal_leaf_2():
+    value = 1
+    assert get_tax(account_id) == value
+
+
+def test_return_variant_1():
+    return
+
+
+def test_return_variant_2():
+    return 1
+
+
+def test_return_variant_3():
+    return 2
+
+
+def test_raise_variant_1():
+    raise ValueError("alpha")
+
+
+def test_raise_variant_2():
+    raise ValueError("alpha") from RuntimeError("cause")
+
+
+def test_raise_variant_3():
+    raise ValueError("beta")
+
+
+def test_more_than_three_parameters_1():
+    assert (1, "alpha", True, None) == (1, "alpha", True, None)
+
+
+def test_more_than_three_parameters_2():
+    assert (2, "beta", False, 1) == (2, "beta", False, 1)
+
+
+def test_more_than_three_parameters_3():
+    assert (3, "gamma", True, 2) == (3, "gamma", True, 2)
+
+
+def test_more_than_three_literal_differences_1():
+    assert get_tax(1) == ("alpha", True, None, 1)
+
+
+def test_more_than_three_literal_differences_2():
+    assert get_tax(2) == ("beta", False, 1, 2)
+
+
+def test_more_than_three_literal_differences_3():
+    assert get_tax(3) == ("gamma", True, 2, 3)
+
+
+def test_repeated_parameter_difference_1():  # Noncompliant {{Group these similar tests into a single parameterized test.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    assert (1, 1, 1, 1) == (1, 1, 1, 1)
+
+
+def test_repeated_parameter_difference_2():
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Similar test.}}
+    assert (2, 2, 2, 2) == (2, 2, 2, 2)
+
+
+def test_repeated_parameter_difference_3():
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^< {{Similar test.}}
+    assert (3, 3, 3, 3) == (3, 3, 3, 3)
+
+
+def test_placeholder1():
+    pass
+
+
+def test_placeholder2():
+    pass
+
+
+def test_placeholder3():
+    pass
+
+
+def test_not_implemented_placeholder1():
+    raise NotImplementedError
+
+
+def test_not_implemented_placeholder2():
+    raise NotImplementedError()
+
+
+def test_not_implemented_placeholder3():
+    raise NotImplementedError("todo")
+
+
+@pytest.mark.xfail
+def test_not_implemented1():
+    raise NotImplementedError
+
+
+@pytest.mark.xfail
+def test_not_implemented2():
+    raise NotImplementedError()
+
+
+@pytest.mark.xfail
+def test_not_implemented3():
+    raise NotImplementedError("todo")
+
+
+class HelperContainer:
+    def test_helper1(self):
+        setup_tax()
+        assert get_tax(1) is not None
+
+    def test_helper2(self):
+        setup_tax()
+        assert get_tax(2) is not None
+
+    def test_helper3(self):
+        setup_tax()
+        assert get_tax(3) is not None
+
+
+class TestMixedKind(unittest.TestCase):
+    def test_mixed_kind_1(self):
+        setup_tax()
+        self.assertIsNotNone(get_tax(1))
+
+
+def test_mixed_kind_2():
+    setup_tax()
+    assert get_tax(2) is not None
+
+
+def test_mixed_kind_3():
+    setup_tax()
+    assert get_tax(3) is not None
+
+
+class TestNestedContainer:
+    class TestInner:
+        def test_nested_tax1(self):  # Noncompliant {{Group these similar tests into a single parameterized test.}}
+#           ^^^^^^^^^^^^^^^^
+            setup_tax()
+            assert get_tax(1) is not None
+
+        def test_nested_tax2(self):
+#           ^^^^^^^^^^^^^^^^< {{Similar test.}}
+            setup_tax()
+            assert get_tax(2) is not None
+
+        def test_nested_tax3(self):
+#           ^^^^^^^^^^^^^^^^< {{Similar test.}}
+            setup_tax()
+            assert get_tax(3) is not None
diff --git a/python-checks/src/test/resources/checks/tests/test_identicalAssertionArguments.py b/python-checks/src/test/resources/checks/tests/test_identicalAssertionArguments.py
new file mode 100644
index 0000000000..1847e2b83d
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_identicalAssertionArguments.py
@@ -0,0 +1,100 @@
+import unittest
+
+from assertpy import assert_that
+
+
+def compute():
+    return 2 + 2
+
+
+def value():
+    return 41 + 1
+
+
+def identity(builder):
+    return builder
+
+
+class Holder:
+    value = 42
+
+
+assert compute() == compute()
+assert_that(compute()).is_equal_to(compute())
+
+
+class TestIdenticalArguments(unittest.TestCase):
+    def noncompliant_equality(self):
+        result = compute()
+#                ^^^^^^^^^>
+        self.assertEqual(result, result)  # Noncompliant {{Replace this assertion to not have the same actual and expected expression.}}
+#                        ^^^^^^> ^^^^^^ 2
+        self.assertNotEqual(result, result)  # Noncompliant
+        self.assertEqual(value(), value())  # Noncompliant
+
+    def noncompliant_identity(self):
+        obj = value()
+        self.assertIs(obj, obj)  # Noncompliant
+        self.assertIsNot(obj, obj)  # Noncompliant
+
+    def noncompliant_keyword_args(self):
+        result = compute()
+        self.assertEqual(first=result, second=result)  # Noncompliant
+        self.assertIs(expr1=result, expr2=result)  # Noncompliant
+
+    def noncompliant_attribute_access(self):
+        holder = Holder()
+        self.assertEqual(holder.value, holder.value)  # Noncompliant
+        self.assertEqual(unknown.attr, unknown.attr)  # Noncompliant
+
+    def compliant(self):
+        result = compute()
+        expected = 4
+        self.assertEqual(result, expected)
+        self.assertEqual(value())
+        self.assertIn(result, [expected])
+
+    def test_dynamic_call_not_checked(self):
+        assertion = self.assertEqual
+        assertion(value(), value())
+
+
+class HelperNonTestCase:
+    def test_not_a_unittest_test_case(self):
+        self.assertEqual(value(), value())
+
+
+def test_identical_pytest_assertions():
+    actual = str(42)
+#            ^^^^^^^>
+    assert actual == actual  # Noncompliant {{Replace this assertion to not have the same actual and expected expression.}}
+#          ^^^^^^>   ^^^^^^ 2
+    assert actual != actual  # Noncompliant
+    assert value() == value()  # Noncompliant
+    holder = Holder()
+    assert holder.value == holder.value  # Noncompliant
+    assert unknown.attr == unknown.attr  # Noncompliant
+    assert actual is actual
+    assert value()
+    assert actual == str(42)
+
+
+def test_identical_assertpy_assertions():
+    actual = str(42)
+#            ^^^^^^^>
+    assert_that(actual).is_equal_to(actual)  # Noncompliant
+#               ^^^^^^>             ^^^^^^ 2
+    assert_that(actual).described_as("count").is_equal_to(actual)  # Noncompliant
+    assert_that(actual).is_not_equal_to(actual)  # Noncompliant
+    assert_that(value()).is_equal_to(value())  # Noncompliant
+    holder = Holder()
+    assert_that(holder.value).is_equal_to(holder.value)  # Noncompliant
+    assert_that(unknown.attr).is_equal_to(unknown.attr)  # Noncompliant
+
+    expected = "42"
+    assert_that(actual).is_equal_to(expected)
+    assert_that(actual).is_equal_to()
+    assert_that().is_equal_to(actual)
+    builder = assert_that(actual)
+    builder.is_equal_to(actual)
+    identity(assert_that(actual)).is_equal_to(actual)
diff --git a/python-checks/src/test/resources/checks/tests/test_pytestParameterDefaultValue.py b/python-checks/src/test/resources/checks/tests/test_pytestParameterDefaultValue.py
new file mode 100644
index 0000000000..605f05fc12
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_pytestParameterDefaultValue.py
@@ -0,0 +1,254 @@
+import pytest
+from pytest import fixture
+
+
+# Compliant: default with no matching fixture — hard-coded optional arg, not blocked injection
+def test_hardcoded_default(threshold=1):
+    assert threshold > 0
+
+
+def test_multiple_hardcoded(a=1, b=2):
+    pass
+
+
+def test_typed_hardcoded(threshold: int = 1):
+    assert threshold > 0
+
+
+def test_none_hardcoded(threshold=None):
+    assert threshold is None
+
+
+@pytest.fixture
+def value():
+    return 42
+
+
+def test_with_default(value=1):  # Noncompliant {{Remove this default value so pytest can inject the parameter.}}
+#                           ^
+    assert value > 0
+
+
+def test_multiple_defaults(value=1, other=2):  # Noncompliant
+#                                ^
+    pass
+
+
+def test_typed_default(value: int = 1):  # Noncompliant
+#                                   ^
+    assert value > 0
+
+
+def test_keyword_only(*, value=1):  # Noncompliant
+#                              ^
+    assert value > 0
+
+
+def test_positional_only(value=1, /):  # Noncompliant
+#                              ^
+    assert value > 0
+
+
+def test_none_default(value=None):  # Noncompliant
+#                           ^^^^
+    assert value is None
+
+
+def test_mutable_default(value=[]):  # Noncompliant
+#                              ^^
+    return value
+
+
+async def test_async_with_default(value=1):  # Noncompliant
+#                                       ^
+    assert value > 0
+
+
+def test_mixed(fixture_ok, value=1):  # Noncompliant
+#                                ^
+    assert value > 0
+
+
+# Builtin fixtures are always known — default blocks injection
+def test_request_default(request=None):  # Noncompliant
+#                                ^^^^
+    pass
+
+
+def test_monkeypatch_default(monkeypatch=None):  # Noncompliant
+#                                        ^^^^
+    pass
+
+
+def test_tmp_path_default(tmp_path=None):  # Noncompliant
+#                                  ^^^^
+    pass
+
+
+class TestClass:
+    @pytest.fixture
+    def class_value(self):
+        return 1
+
+    def test_method_with_default(self, class_value=1):  # Noncompliant
+#                                                  ^
+        assert class_value > 0
+
+    def test_method_module_fixture(self, value=1):  # Noncompliant
+#                                              ^
+        assert value > 0
+
+    @pytest.fixture
+    def class_fixture_with_default(self, value=1):  # Noncompliant
+#                                              ^
+        return value
+
+
+@pytest.fixture
+def fixture_with_default(value=1):  # Noncompliant
+#                              ^
+    return value
+
+
+@pytest.fixture()
+def fixture_call_with_default(value=1):  # Noncompliant
+#                                   ^
+    return value
+
+
+@fixture
+def imported_fixture_with_default(value=1):  # Noncompliant
+#                                       ^
+    return value
+
+
+@pytest.fixture
+async def async_fixture_with_default(value=1):  # Noncompliant
+#                                          ^
+    return value
+
+
+@pytest.fixture(name="renamed")
+def _internal_name():
+    return 1
+
+
+def test_renamed_fixture(renamed=0):  # Noncompliant
+#                                ^
+    assert renamed >= 0
+
+
+# Compliant: no defaults
+def test_without_default(value):
+    assert value > 0
+
+
+def test_multiple_params(a, b, c):
+    pass
+
+
+def test_variadic(*args, **kwargs):
+    pass
+
+
+@pytest.fixture
+def fixture_without_default(value):
+    return value
+
+
+@fixture()
+def imported_fixture_ok(value):
+    return value
+
+
+class TestCompliant:
+    def test_method(self, value):
+        assert value > 0
+
+    @pytest.fixture
+    def class_fixture(self, value):
+        return value
+
+
+# Compliant: not a test or fixture
+def helper_with_default(value=1):
+    return value
+
+
+def not_a_test(value=1):
+    return value
+
+
+# Compliant: test*-named method in a non-Test class is not collected by pytest
+class DataBuilder:
+    def test_data(self, size=10):
+        return size
+
+
+# Compliant: nested helper named test_* inside a non-test class
+class TestS3Hook:
+    def test_provide_bucket_name(self):
+        class FakeS3Hook:
+            def test_function(self, bucket_name=None):
+                return bucket_name
+
+
+# Compliant: unittest-style helpers with hardcoded defaults and no matching fixture
+class ComparisonTest:
+    def test_valid(self, position=None):
+        pass
+
+
+class DigestAuthTests:
+    def test_hash(self, algorithm='md5'):
+        pass
+
+
+class test_DynamoDBBackend:
+    def test_backend_by_url(self, url='dynamodb://'):
+        pass
+
+
+class RemoteFuncsTestCase:
+    def test_pub_ret(self, load=None):
+        pass
+
+
+# Compliant: class fixture is not available outside its class
+class TestOther:
+    def test_no_class_fixture(self, class_value=1):
+        assert class_value > 0
+
+
+@pytest.mark.parametrize("value", [1, 2])
+def test_parametrized_without_default(value):
+    assert value > 0
+
+
+# Parametrize injects the arg — default is unused / incorrect
+@pytest.mark.parametrize("arg", [1, 2])
+def test_parametrized_with_hardcoded(arg=0):  # Noncompliant
+#                                        ^
+    assert arg >= 0
+
+
+@pytest.mark.parametrize("value", [1, 2])
+def test_parametrized_with_default(value=0):  # Noncompliant
+#                                        ^
+    assert value >= 0
+
+
+@pytest.mark.parametrize(("left", "right"), [(1, 2), (3, 4)])
+def test_parametrized_tuple_names(left=0, right=1):  # Noncompliant 2
+    pass
+
+
+@pytest.mark.parametrize("a,b", [(1, 2)])
+def test_parametrized_csv_names(a=0, b=1):  # Noncompliant 2
+    pass
+
+
+# Compliant: default on a non-parametrized, non-fixture parameter alongside parametrize
+@pytest.mark.parametrize("case", [1, 2])
+def test_parametrized_with_unrelated_default(case, threshold=10):
+    assert case < threshold
diff --git a/python-checks/src/test/resources/checks/tests/test_pytestPluginsConftest.py b/python-checks/src/test/resources/checks/tests/test_pytestPluginsConftest.py
new file mode 100644
index 0000000000..b02ccfc017
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_pytestPluginsConftest.py
@@ -0,0 +1,14 @@
+pytest_plugins = ["pytest_cov", "pytest_timeout"]  # Noncompliant {{"pytest_plugins" should be defined in conftest.py files}}
+pytest_plugins: list[str] = ["pytest_cov"]  # Noncompliant {{"pytest_plugins" should be defined in conftest.py files}}
+pytest_plugins: list[str]
+
+other_plugins = ["pytest_cov"]
+
+def test_feature():
+    assert other_plugins[0] == "pytest_cov"
+
+def nested():
+    pytest_plugins = ["pytest_cov"]
+
+class TestClass:
+    pytest_plugins = ["pytest_cov"]
diff --git a/python-checks/src/test/resources/checks/tests/test_useMonkeypatchFixture.py b/python-checks/src/test/resources/checks/tests/test_useMonkeypatchFixture.py
new file mode 100644
index 0000000000..11531c4258
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_useMonkeypatchFixture.py
@@ -0,0 +1,222 @@
+import os
+import sys
+
+import myapp.client
+import myapp.config
+import pytest
+
+
+def test_api_key():
+    old_key = os.environ.get('API_KEY')
+    os.environ['API_KEY'] = 'test_key'  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+#   ^^^^^^^^^^^^^^^^^^^^^
+    result = get_api_configuration()
+    assert result['key'] == 'test_key'
+    if old_key:
+        os.environ['API_KEY'] = old_key  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+    else:
+        del os.environ['API_KEY']  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+
+
+def test_api_key_compliant(monkeypatch):
+    monkeypatch.setenv('API_KEY', 'test_key')
+    result = get_api_configuration()
+    assert result['key'] == 'test_key'
+
+
+def test_feature_flag():
+    old_value = myapp.config.ENABLE_FEATURE
+    myapp.config.ENABLE_FEATURE = True  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    assert myapp.is_feature_enabled()
+    myapp.config.ENABLE_FEATURE = old_value  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+
+
+def test_feature_flag_compliant(monkeypatch):
+    monkeypatch.setattr(myapp.config, 'ENABLE_FEATURE', True)
+    assert myapp.is_feature_enabled()
+
+
+def test_notify_user():
+    client = myapp.client.Client()
+    original_send = client.send
+    client.send = lambda message: {"sent": True}
+    result = client.notify("Hello")
+    assert result["sent"]
+    client.send = original_send
+
+
+def test_notify_user_compliant(monkeypatch):
+    client = myapp.client.Client()
+    monkeypatch.setattr(client, "send", lambda message: {"sent": True})
+    result = client.notify("Hello")
+    assert result["sent"]
+
+
+def helper_set_env():
+    os.environ['API_KEY'] = 'test_key'
+
+
+def test_calls_helper():
+    helper_set_env()
+    assert True
+
+
+def not_a_test():
+    os.environ['API_KEY'] = 'test_key'
+
+
+def test_nested_helper():
+    def inner():
+        os.environ['API_KEY'] = 'test_key'
+
+    inner()
+    assert True
+
+
+def test_parenthesized_environ():
+    (os.environ)['API_KEY'] = 'test_key'  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_multiple_delete():
+    os.environ['A'] = '1'  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+    os.environ['B'] = '2'  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+    del os.environ['A']  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+
+
+@pytest.fixture
+def test_with_fixture_decorator():
+    os.environ['FIXTURE_VAR'] = '1'
+
+
+@pytest.fixture()
+def test_with_call_fixture_decorator():
+    os.environ['FIXTURE_VAR'] = '1'
+
+
+@pytest.fixture
+def setup_env():
+    os.environ['API_KEY'] = 'test_key'
+    yield
+    del os.environ['API_KEY']
+
+
+@pytest.fixture()
+def setup_env_with_call_decorator():
+    os.environ['TEMP_VAR'] = 'temp'
+    yield
+    del os.environ['TEMP_VAR']
+
+
+def setup_module():
+    os.environ['API_KEY'] = 'test_key'
+
+
+def teardown_module():
+    del os.environ['API_KEY']
+
+
+class TestApp:
+    def test_instance_attribute(self):
+        self.value = 1
+        assert self.value == 1
+
+    def setup_method(self):
+        os.environ['SETUP'] = '1'
+
+    def teardown_method(self):
+        del os.environ['SETUP']
+
+def test_sys_path_insert():
+    sys.path.insert(0, '/tmp/test')  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_sys_path_subscription():
+    sys.path[0] = '/tmp/test'  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+#   ^^^^^^^^^^^
+
+
+def test_module_attribute_subscription_chain():
+    myapp.config.SETTINGS['key'].value = 'value'  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+
+def test_sys_path_insert_compliant(monkeypatch):
+    monkeypatch.syspath_prepend('/tmp/test')
+
+
+# --- FP analysis reproducers (should remain compliant) ---
+
+class PodSpec:
+    def __init__(self):
+        self.containers = [type('C', (), {})()]
+
+
+class Pod:
+    def __init__(self):
+        self.spec = PodSpec()
+        self.metadata = type('M', (), {'labels': {}, 'annotations': None, 'name': None, 'namespace': None})()
+
+
+def test_local_nested_subscription_chain():
+    expected = Pod()
+    expected.metadata.labels = {}
+    expected.metadata.name = 'pod_id'
+    expected.metadata.namespace = 'test_namespace'
+    expected.spec.containers[0].args = ['command']
+    expected.spec.containers[0].image = 'img'
+    expected.spec.containers[0].resources = {'limits': {'cpu': '1m', 'memory': '1G'}}
+
+
+def test_local_subscription_then_attribute():
+    clf = type('Clf', (), {'inputs': [type('In', (), {})()], 'outputs': [type('Out', (), {'in_blocks': [type('B', (), {})()]})()]})()
+    clf.inputs[0].shape = (32, 32, 3)
+    clf.outputs[0].in_blocks[0].shape = (10,)
+
+
+def test_mock_call_return_attribute_assignment():
+    mock_post = type('M', (), {'__call__': lambda self: type('R', (), {})()})()
+    mock_post().ok = False
+    mock_post().text = 'content'
+    mock_post().headers = {}
+
+
+def test_call_return_attribute_assignment():
+    def get_ti_from_db(task):
+        return type('TI', (), {'state': None})()
+
+    get_ti_from_db('task_1').state = 'FAILED'
+    get_ti_from_db('task_2').state = 'SUCCESS'
+
+
+def test_getattr_result_attribute_assignment():
+    float_frame = type('F', (), {'index': type('I', (), {'name': None})()})()
+    getattr(float_frame, 'index').name = 'foo'
+
+
+def test_nested_self_subscription_attribute():
+    class TestBuilders:
+        def __init__(self):
+            self.builders = {'A': type('B', (), {})()}
+
+        def test_nested_self(self):
+            self.builders['A'].maybeStartBuild = lambda: None
+
+
+def test_workbook_local_nested_assignment():
+    wb = type('WB', (), {'worksheets': [type('WS', (), {'title': None})(), type('WS', (), {})()]})()
+    wb.worksheets[0].title = 'foo'
+    wb.worksheets[0]['A1'] = type('Cell', (), {'value': None})()
+    wb.worksheets[0]['A1'].value = 'foo'
+
+
+def test_local_dataframe_nested_flags():
+    df = type('DF', (), {'_mgr': type('Mgr', (), {'blocks': [type('Blk', (), {'values': type('V', (), {'flags': type('F', (), {'writeable': True})()})()})()]})()})()
+    df._mgr.blocks[0].values.flags.writeable = False
+
+
+def test_module_attr_still_detected():
+    myapp.config.ENABLE_FEATURE = True  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/python-checks/src/test/resources/checks/tests/test_useMonkeypatchFixture_lifecycle.py b/python-checks/src/test/resources/checks/tests/test_useMonkeypatchFixture_lifecycle.py
new file mode 100644
index 0000000000..546c21b46f
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_useMonkeypatchFixture_lifecycle.py
@@ -0,0 +1,42 @@
+import os
+
+
+def setup_module():
+    os.environ['MODULE_SETUP'] = '1'
+
+
+def teardown_module():
+    del os.environ['MODULE_SETUP']
+
+
+def setup_class():
+    os.environ['CLASS_SETUP'] = '1'
+
+
+def teardown_class():
+    del os.environ['CLASS_SETUP']
+
+
+def setup_method():
+    os.environ['METHOD_SETUP'] = '1'
+
+
+def teardown_method():
+    del os.environ['METHOD_SETUP']
+
+
+class TestLifecycle:
+    def setUp(self):
+        os.environ['SETUP'] = '1'
+
+    def tearDown(self):
+        del os.environ['SETUP']
+
+    def setUpClass(cls):
+        os.environ['SETUP_CLASS'] = '1'
+
+    def tearDownClass(cls):
+        del os.environ['SETUP_CLASS']
+
+    def test_ok(self):
+        assert True
diff --git a/python-checks/src/test/resources/checks/tests/test_useTmpPathInsteadOfFactory.py b/python-checks/src/test/resources/checks/tests/test_useTmpPathInsteadOfFactory.py
new file mode 100644
index 0000000000..de860514ff
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/test_useTmpPathInsteadOfFactory.py
@@ -0,0 +1,86 @@
+import pytest
+
+
+def test_file_operation(tmp_path_factory):  # Noncompliant {{Use "tmp_path" instead of "tmp_path_factory" in function-scoped tests.}}
+#                       ^^^^^^^^^^^^^^^^
+    temp_dir = tmp_path_factory.mktemp('data')
+    test_file = temp_dir / 'test.txt'
+    test_file.write_text('content')
+    assert test_file.read_text() == 'content'
+
+
+def test_with_other_fixtures(tmp_path_factory, monkeypatch):  # Noncompliant
+#                            ^^^^^^^^^^^^^^^^
+    temp_dir = tmp_path_factory.mktemp('data')
+    assert temp_dir.exists()
+
+
+async def test_async(tmp_path_factory):  # Noncompliant
+#                    ^^^^^^^^^^^^^^^^
+    temp_dir = tmp_path_factory.mktemp('data')
+    assert temp_dir.exists()
+
+
+@pytest.mark.parametrize("value", [1, 2])
+def test_parametrized(tmp_path_factory, value):  # Noncompliant
+#                     ^^^^^^^^^^^^^^^^
+    assert (tmp_path_factory.mktemp('data') / str(value)).parent.exists()
+
+
+class TestSomething:
+    def test_method(self, tmp_path_factory):  # Noncompliant
+#                         ^^^^^^^^^^^^^^^^
+        temp_dir = tmp_path_factory.mktemp('data')
+        assert temp_dir.exists()
+
+
+def test_file_operation_compliant(tmp_path):
+    test_file = tmp_path / 'test.txt'
+    test_file.write_text('content')
+    assert test_file.read_text() == 'content'
+
+
+def test_no_tmp_path():
+    assert True
+
+
+@pytest.fixture
+def function_scoped_fixture(tmp_path_factory):
+    return tmp_path_factory.mktemp('data')
+
+
+@pytest.fixture(scope="session")
+def session_data(tmp_path_factory):
+    return tmp_path_factory.mktemp('session')
+
+
+@pytest.fixture(scope="module")
+def module_data(tmp_path_factory):
+    return tmp_path_factory.mktemp('module')
+
+
+@pytest.fixture(scope="class")
+def class_data(tmp_path_factory):
+    return tmp_path_factory.mktemp('class')
+
+
+@pytest.fixture(scope="package")
+def package_data(tmp_path_factory):
+    return tmp_path_factory.mktemp('package')
+
+
+def helper_not_a_test(tmp_path_factory):
+    return tmp_path_factory.mktemp('helper')
+
+
+def setup_module(tmp_path_factory):
+    return tmp_path_factory.mktemp('setup')
+
+
+class TestHelpers:
+    def helper_method(self, tmp_path_factory):
+        return tmp_path_factory.mktemp('helper')
+
+    @pytest.fixture
+    def test_looking_fixture(self, tmp_path_factory):
+        return tmp_path_factory.mktemp('fixture')
diff --git a/python-checks/src/test/resources/checks/tests/useMonkeypatchFixture.py b/python-checks/src/test/resources/checks/tests/useMonkeypatchFixture.py
new file mode 100644
index 0000000000..28efd1e189
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/useMonkeypatchFixture.py
@@ -0,0 +1,7 @@
+import os
+
+import myapp.config
+
+
+def test_api_key():
+    os.environ['API_KEY'] = 'test_key'
diff --git a/python-checks/src/test/resources/checks/tests/useMonkeypatchFixture_test.py b/python-checks/src/test/resources/checks/tests/useMonkeypatchFixture_test.py
new file mode 100644
index 0000000000..e86c1bae02
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/useMonkeypatchFixture_test.py
@@ -0,0 +1,5 @@
+import os
+
+
+def test_suffix():
+    os.environ['API_KEY'] = 'test_key'  # Noncompliant {{Use the "monkeypatch" fixture for temporary modifications instead of manually modifying global state.}}
diff --git a/python-checks/src/test/resources/checks/tests/useTmpPathInsteadOfFactory.py b/python-checks/src/test/resources/checks/tests/useTmpPathInsteadOfFactory.py
new file mode 100644
index 0000000000..e523f38ae3
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/useTmpPathInsteadOfFactory.py
@@ -0,0 +1,6 @@
+# Not a pytest-collected file name — no issues expected.
+
+
+def test_file_operation(tmp_path_factory):
+    temp_dir = tmp_path_factory.mktemp('data')
+    assert temp_dir.exists()
diff --git a/python-checks/src/test/resources/checks/tests/useTmpPathInsteadOfFactory_test.py b/python-checks/src/test/resources/checks/tests/useTmpPathInsteadOfFactory_test.py
new file mode 100644
index 0000000000..a0374cd1b2
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/useTmpPathInsteadOfFactory_test.py
@@ -0,0 +1,4 @@
+def test_file_operation(tmp_path_factory):  # Noncompliant {{Use "tmp_path" instead of "tmp_path_factory" in function-scoped tests.}}
+#                       ^^^^^^^^^^^^^^^^
+    temp_dir = tmp_path_factory.mktemp('data')
+    assert temp_dir.exists()
diff --git a/python-checks/src/test/resources/checks/tests/uselessPytestMarks.py b/python-checks/src/test/resources/checks/tests/uselessPytestMarks.py
new file mode 100644
index 0000000000..67c02b9a4b
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/uselessPytestMarks.py
@@ -0,0 +1,169 @@
+import pytest
+from pytest import fixture, mark
+from pytest.mark import usefixtures, skip
+
+
+@pytest.mark.asyncio  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=20]
+@pytest.fixture
+async def db_async_mark():
+    return await connect()
+
+
+@pytest.mark.usefixtures("db")  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=30]
+@pytest.fixture
+def client_usefixtures_on_fixture(db):
+    return Client(db)
+
+
+@pytest.mark.slow  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=17]
+@pytest.fixture
+def cache_custom_mark():
+    return {}
+
+
+@pytest.mark.parametrize("x", [1, 2])  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=37]
+@pytest.fixture
+def parametrized_fixture(x):
+    return x
+
+
+@pytest.mark.skip  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=17]
+@pytest.fixture
+def skipped_fixture():
+    return 1
+
+
+@pytest.fixture
+@pytest.mark.asyncio  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=20]
+async def mark_below_fixture():
+    return 1
+
+
+@pytest.mark.slow  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=17]
+@pytest.mark.usefixtures("db")  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=30]
+@pytest.fixture
+def multiple_marks_on_fixture():
+    return 1
+
+
+@mark.slow  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=10]
+@fixture
+def imported_mark_on_fixture():
+    return 1
+
+
+@pytest.fixture
+@skip  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=5]
+def imported_skip_on_fixture():
+    return 1
+
+
+@pytest.mark.usefixtures()  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=26]
+@pytest.fixture
+def empty_usefixtures_on_fixture():
+    return 1
+
+
+@pytest.mark.usefixtures  # Noncompliant {{Remove this mark; it has no effect on fixtures.}}
+#^[sc=1;ec=24]
+@pytest.fixture
+def bare_usefixtures_on_fixture():
+    return 1
+
+
+@pytest.mark.usefixtures()  # Noncompliant {{Provide fixture names or remove this empty usefixtures decorator.}}
+#^[sc=1;ec=26]
+def test_empty_usefixtures():
+    assert ping() == "pong"
+
+
+@pytest.mark.usefixtures()  # Noncompliant {{Provide fixture names or remove this empty usefixtures decorator.}}
+#^[sc=1;ec=26]
+class TestEmptyUsefixtures:
+    def test_something(self):
+        assert True
+
+
+@mark.usefixtures()  # Noncompliant {{Provide fixture names or remove this empty usefixtures decorator.}}
+#^[sc=1;ec=19]
+def test_empty_usefixtures_via_mark_import():
+    assert True
+
+
+@usefixtures()  # Noncompliant {{Provide fixture names or remove this empty usefixtures decorator.}}
+#^[sc=1;ec=14]
+def test_empty_usefixtures_direct_import():
+    assert True
+
+
+# Compliant: clean fixtures
+@pytest.fixture
+async def db():
+    return await connect()
+
+
+@pytest.fixture
+def client(db):
+    return Client(db)
+
+
+@fixture
+def cache():
+    return {}
+
+
+# Compliant: marks on tests / classes (not fixtures)
+@pytest.mark.asyncio
+async def test_async():
+    assert True
+
+
+@pytest.mark.slow
+def test_slow():
+    assert True
+
+
+@pytest.mark.usefixtures("db")
+def test_with_usefixtures():
+    assert True
+
+
+@pytest.mark.usefixtures
+def test_bare_usefixtures():
+    assert True
+
+
+@pytest.mark.usefixtures("db", "cache")
+class TestWithUsefixtures:
+    def test_something(self):
+        assert True
+
+
+@mark.parametrize("x", [1])
+def test_parametrized(x):
+    assert x == 1
+
+
+@pytest.mark.skip(reason="not ready")
+def test_skipped():
+    assert False
+
+
+def not_a_test():
+    pass
+
+
+@pytest.mark.slow
+def helper_not_fixture():
+    return 1
diff --git a/python-checks/src/test/resources/checks/tests/xfailNoReason.py b/python-checks/src/test/resources/checks/tests/xfailNoReason.py
new file mode 100644
index 0000000000..194113253b
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/xfailNoReason.py
@@ -0,0 +1,51 @@
+import pytest
+
+
+class UsingPytest:
+    @pytest.mark.xfail  # Noncompliant {{Provide a reason for marking this test as expected to fail.}}
+#   ^^^^^^^^^^^^^^^^^^
+    def test_xfail_no_reason(self):
+        assert 1 == 2
+
+    @pytest.mark.xfail()  # Noncompliant {{Provide a reason for marking this test as expected to fail.}}
+#   ^^^^^^^^^^^^^^^^^^^^
+    def test_xfail_call_without_reason(self):
+        assert 1 == 2
+
+    @pytest.mark.xfail(reason="Issue #456: known bug")
+    def test_xfail_with_reason(self):
+        assert 1 == 2
+
+    @pytest.mark.xfail(reason="")  # Noncompliant {{Provide a reason for marking this test as expected to fail.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    def test_xfail_empty_reason(self):
+        assert 1 == 2
+
+    @pytest.mark.xfail(reason=" ")
+    def test_xfail_blank_reason(self):
+        assert 1 == 2
+
+    @pytest.mark.xfail(condition=True)  # Noncompliant {{Provide a reason for marking this test as expected to fail.}}
+#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    def test_xfail_with_condition_only(self):
+        assert 1 == 2
+
+    @pytest.mark.xfail(reason=other_var)
+    def test_xfail_with_variable_reason(self):
+        assert 1 == 2
+
+    @pytest.mark.skip
+    def test_skip_not_xfail(self):
+        assert 1 == 2
+
+    @bob.bob
+    def test_qualified_expression_null_symbol(self):
+        assert 1 == 2
+
+    @xfail()
+    def test_xfail_symbol_not_defined_ok(self):
+        assert 1 == 2
+
+    @"my string"
+    def test_decorator_without_symbol_ok(self):
+        assert 1 == 2
diff --git a/python-checks/src/test/resources/checks/tests/xfailNoReasonWithImport.py b/python-checks/src/test/resources/checks/tests/xfailNoReasonWithImport.py
new file mode 100644
index 0000000000..86e662e6bf
--- /dev/null
+++ b/python-checks/src/test/resources/checks/tests/xfailNoReasonWithImport.py
@@ -0,0 +1,17 @@
+from pytest.mark import xfail
+
+
+class UsingPytest:
+    @xfail  # Noncompliant {{Provide a reason for marking this test as expected to fail.}}
+#   ^^^^^^
+    def test_xfail_no_reason(self):
+        assert 1 == 2
+
+    @xfail()  # Noncompliant {{Provide a reason for marking this test as expected to fail.}}
+#   ^^^^^^^^
+    def test_xfail_call_without_reason(self):
+        assert 1 == 2
+
+    @xfail(reason="Issue #456: known bug")
+    def test_xfail_with_reason(self):
+        assert 1 == 2
diff --git a/python-checks/src/test/resources/checks/torchAutogradVariable.py b/python-checks/src/test/resources/checks/torchAutogradVariable.py
index b98d9b3948..83bd60cc01 100644
--- a/python-checks/src/test/resources/checks/torchAutogradVariable.py
+++ b/python-checks/src/test/resources/checks/torchAutogradVariable.py
@@ -1,40 +1,51 @@
 def torch_import():
     import torch
 
-    x6 = Variable(torch.tensor([15])) 
+    x6 = Variable(torch.tensor([15]))
 
-    x = torch.autograd.Variable(torch.tensor([1.0]), requires_grad=True) # Noncompliant {{Replace this call with a call to "torch.tensor".}}
-       #^^^^^^^^^^^^^^^^^^^^^^^
-    x2 = torch.autograd.Variable(torch.tensor([1.0])) # Noncompliant
-        #^^^^^^^^^^^^^^^^^^^^^^^
-        
-    x4 = torch.autograd.Variable() # Noncompliant
+    x = torch.autograd.Variable(  # Noncompliant {{Replace this call with a call to "torch.tensor".}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^^
+        torch.tensor([1.0]),
+        requires_grad=True,
+    )
+    x2 = torch.autograd.Variable(torch.tensor([1.0]))  # Noncompliant
+
+    x4 = torch.autograd.Variable()  # Noncompliant
 
     # Compliant solution
     c_x3 = torch.tensor([1.0])
 
+
 def torch_autograd_import_as():
     from torch.autograd import Variable as V
-    x3 = V(torch.tensor([15])) # Noncompliant
-        #^
-    
+
+    x3 = V(torch.tensor([15]))  # Noncompliant
+#        ^
+
+
 def torch_alias_import():
     import torch as t
-    x5 = t.autograd.Variable(torch.tensor([15])) # Noncompliant
+
+    x5 = t.autograd.Variable(torch.tensor([15]))  # Noncompliant
 
 
 def unrelated_import():
     from something.autograd import Variable
-    x6 = Variable(torch.tensor([15])) 
+
+    x6 = Variable(torch.tensor([15]))
+
 
 def multiple_imports():
-    # Resulting symbol will be ambiguous, therefore no issue is raised
     from something.autograd import Variable
-    x6 = Variable(torch.tensor([15])) 
+
+    x6 = Variable(torch.tensor([15]))
     from torch.autograd import Variable
-    x6 = Variable(torch.tensor([15])) 
 
-def use_before_assignment():
     x6 = Variable(torch.tensor([15]))  # Noncompliant
+
+
+def use_before_assignment():
+    x6 = Variable(torch.tensor([15]))
     from torch.autograd import Variable
+
     x6 = Variable(torch.tensor([15]))  # Noncompliant
diff --git a/python-checks/src/test/resources/checks/typeVarCovariantAndContravariant.py b/python-checks/src/test/resources/checks/typeVarCovariantAndContravariant.py
new file mode 100644
index 0000000000..57c48c176a
--- /dev/null
+++ b/python-checks/src/test/resources/checks/typeVarCovariantAndContravariant.py
@@ -0,0 +1,111 @@
+from typing import TypeVar
+from typing import TypeVar as TV
+from typing_extensions import TypeVar as ExtTV
+import typing
+import typing_extensions
+
+T1 = TypeVar('T1', covariant=True, contravariant=True)  # Noncompliant
+#    ^^^^^^^
+T2 = TypeVar('T2', contravariant=True, covariant=True)  # Noncompliant
+#    ^^^^^^^
+T3 = TypeVar('T3', int, str, covariant=True, contravariant=True)  # Noncompliant
+#    ^^^^^^^
+T4 = TypeVar('T4', bound=int, covariant=True, contravariant=True)  # Noncompliant
+#    ^^^^^^^
+T5 = typing.TypeVar('T5', covariant=True, contravariant=True)  # Noncompliant
+#    ^^^^^^^^^^^^^^
+T6 = typing_extensions.TypeVar('T6', covariant=True, contravariant=True)  # Noncompliant
+#    ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+cov = True
+T7 = TypeVar('T7', covariant=cov, contravariant=True)  # Noncompliant
+#    ^^^^^^^
+
+contra = True
+T8 = TypeVar('T8', covariant=True, contravariant=contra)  # Noncompliant
+#    ^^^^^^^
+
+cov2 = True
+contra2 = True
+T9 = TypeVar('T9', covariant=cov2, contravariant=contra2)  # Noncompliant
+#    ^^^^^^^
+
+
+T_co = TypeVar('T_co', covariant=True)
+T_contra = TypeVar('T_contra', contravariant=True)
+T_inv = TypeVar('T_inv')
+T_inv2 = TypeVar('T_inv2', covariant=False, contravariant=False)
+T_inv3 = TypeVar('T_inv3', covariant=True, contravariant=False)
+T_inv4 = TypeVar('T_inv4', covariant=False, contravariant=True)
+T_ext_co = typing_extensions.TypeVar('T_ext_co', covariant=True)
+T_ext_contra = typing_extensions.TypeVar('T_ext_contra', contravariant=True)
+
+
+def get_flag():
+    return True
+
+
+T_unk = TypeVar('T_unk', covariant=get_flag(), contravariant=True)
+T_unk2 = TypeVar('T_unk2', covariant=True, contravariant=get_flag())
+
+
+def my_func(name, covariant=False, contravariant=False):
+    pass
+
+
+my_func('X', covariant=True, contravariant=True)
+
+
+cov3 = False
+cov3 = True
+T_fn = TypeVar('T_fn', covariant=cov3, contravariant=True)
+
+cov_false = False
+T_false_name = TypeVar('T_false_name', covariant=cov_false, contravariant=True)
+
+T_num_noncompliant = TypeVar('T_num_noncompliant', covariant=1, contravariant=1)  # Noncompliant
+T_num_mixed = TypeVar('T_num_mixed', covariant=1, contravariant=True)  # Noncompliant
+
+T_num_zero_cov = TypeVar('T_num_zero_cov', covariant=0, contravariant=True)
+T_num_zero_contra = TypeVar('T_num_zero_contra', covariant=True, contravariant=0)
+T_num_zero_both = TypeVar('T_num_zero_both', covariant=0, contravariant=0)
+
+T_float_zero_cov = TypeVar('T_float_zero_cov', covariant=0.0, contravariant=True)
+T_float_zero_contra = TypeVar('T_float_zero_contra', covariant=True, contravariant=0.0)
+
+T_complex_zero_cov = TypeVar('T_complex_zero_cov', covariant=0j, contravariant=True)
+T_complex_zero_contra = TypeVar('T_complex_zero_contra', covariant=True, contravariant=0j)
+
+T_none_cov = TypeVar('T_none_cov', covariant=None, contravariant=True)
+T_none_contra = TypeVar('T_none_contra', covariant=True, contravariant=None)
+
+T_str_noncompliant = TypeVar('T_str_noncompliant', covariant="yes", contravariant=True)  # Noncompliant
+T_str_empty_cov = TypeVar('T_str_empty_cov', covariant="", contravariant=True)
+
+T_list_empty_cov = TypeVar('T_list_empty_cov', covariant=[], contravariant=True)
+T_list_empty_contra = TypeVar('T_list_empty_contra', covariant=True, contravariant=[])
+T_list_nonempty = TypeVar('T_list_nonempty', covariant=[1], contravariant=True)  # Noncompliant
+
+T_tuple_empty_cov = TypeVar('T_tuple_empty_cov', covariant=(), contravariant=True)
+T_tuple_empty_contra = TypeVar('T_tuple_empty_contra', covariant=True, contravariant=())
+T_tuple_nonempty = TypeVar('T_tuple_nonempty', covariant=(1,), contravariant=True)  # Noncompliant
+
+T_dict_empty_cov = TypeVar('T_dict_empty_cov', covariant={}, contravariant=True)
+T_dict_empty_contra = TypeVar('T_dict_empty_contra', covariant=True, contravariant={})
+T_dict_nonempty = TypeVar('T_dict_nonempty', covariant={1: 2}, contravariant=True)  # Noncompliant
+
+T_set_nonempty = TypeVar('T_set_nonempty', covariant={1, 2}, contravariant=True)  # Noncompliant
+
+T_ext_inv = typing_extensions.TypeVar('T_ext_inv', covariant=False, contravariant=False)
+
+T_alias = TV('T_alias', covariant=True, contravariant=True)  # Noncompliant
+#         ^^
+T_ext_alias = ExtTV('T_ext_alias', covariant=True, contravariant=True)  # Noncompliant
+#             ^^^^^
+
+T_str_contra_truthy = TypeVar('T_str_contra_truthy', covariant=True, contravariant="yes")  # Noncompliant
+#                     ^^^^^^^
+T_str_empty_contra = TypeVar('T_str_empty_contra', covariant=True, contravariant="")
+
+kwargs_with_covariant = {'covariant': True, 'contravariant': True}
+T_kwargs_unpacked = TypeVar('T_kwargs_unpacked', **kwargs_with_covariant)
diff --git a/python-checks/src/test/resources/checks/typeVarNamingConvention.py b/python-checks/src/test/resources/checks/typeVarNamingConvention.py
new file mode 100644
index 0000000000..ea9973a2b7
--- /dev/null
+++ b/python-checks/src/test/resources/checks/typeVarNamingConvention.py
@@ -0,0 +1,212 @@
+from typing import TypeVar, ParamSpec, NewType
+from typing import TypeVar as TV
+from typing import ParamSpec as PS
+from typing import NewType as NT
+from typing_extensions import TypeVar as ExtTV
+from typing_extensions import ParamSpec as ExtPS
+from typing_extensions import NewType as ExtNewType
+import typing
+import typing_extensions
+
+MyType = TypeVar("T")  # Noncompliant {{Rename this string to match the variable name "MyType".}}
+#                ^^^
+
+MyParams = ParamSpec("P")  # Noncompliant {{Rename this string to match the variable name "MyParams".}}
+#                    ^^^
+
+MyInt = NewType("Integer", int)  # Noncompliant {{Rename this string to match the variable name "MyInt".}}
+#               ^^^^^^^^^
+
+AnotherType = typing.TypeVar("T")  # Noncompliant {{Rename this string to match the variable name "AnotherType".}}
+#                            ^^^
+
+MyPS = typing.ParamSpec("P")  # Noncompliant {{Rename this string to match the variable name "MyPS".}}
+#                       ^^^
+
+MyNewType = typing.NewType("OtherName", int)  # Noncompliant
+#                          ^^^^^^^^^^^
+
+MyExtType = typing_extensions.TypeVar("E")  # Noncompliant
+#                                     ^^^
+
+MyExtParams = typing_extensions.ParamSpec("P")  # Noncompliant
+#                                         ^^^
+
+MyExtInt = typing_extensions.NewType("ExtInteger", int)  # Noncompliant
+#                                    ^^^^^^^^^^^^
+
+MyAliasType = TV("T")  # Noncompliant
+#                ^^^
+
+MyAliasParams = PS("Params")  # Noncompliant
+#                  ^^^^^^^^
+
+MyAliasInt = NT("UserId", int)  # Noncompliant
+#               ^^^^^^^^
+
+MyExtAliasType = ExtTV("E")  # Noncompliant
+#                      ^^^
+
+MyExtAliasParams = ExtPS("Params")  # Noncompliant
+#                        ^^^^^^^^
+
+MyExtAliasInt = ExtNewType("OtherName", int)  # Noncompliant
+#                          ^^^^^^^^^^^
+
+MyVar = TypeVar("myVar")  # Noncompliant
+#               ^^^^^^^
+
+T_co = TypeVar("T_contra")  # Noncompliant
+#              ^^^^^^^^^^
+
+UserId = NewType("UserID", int)  # Noncompliant
+#                ^^^^^^^^
+
+ElementType = TypeVar("E")  # Noncompliant
+#                     ^^^
+
+NewName = TypeVar("OldName")  # Noncompliant
+#                 ^^^^^^^^^
+
+NumberType = TypeVar("Num", int, float)  # Noncompliant
+#                    ^^^^^
+
+ComparableType = TypeVar("Comparable", bound=int)  # Noncompliant
+#                        ^^^^^^^^^^^^
+
+MyCovariantType = TypeVar("T_co", covariant=True)  # Noncompliant
+#                         ^^^^^^
+
+MyContraType = TypeVar("T_contra", contravariant=True)  # Noncompliant
+#                      ^^^^^^^^^^
+
+EmptyStr = TypeVar("")  # Noncompliant
+#                  ^^
+
+MySingleQuoteType = TypeVar('MySingleQuoteTypo')  # Noncompliant
+#                           ^^^^^^^^^^^^^^^^^^^
+
+
+def noncompliant_inside_function():
+    InnerType = TypeVar("T")  # Noncompliant
+#                       ^^^
+    InnerParams = ParamSpec("P")  # Noncompliant
+#                           ^^^
+    InnerNew = NewType("OtherName", int)  # Noncompliant
+#                      ^^^^^^^^^^^
+
+
+class MyGenericClass:
+    ClassVar1 = TypeVar("T")  # Noncompliant
+#                       ^^^
+    ClassVar2 = ParamSpec("P")  # Noncompliant
+#                         ^^^
+    ClassVar3 = NewType("OtherName", int)  # Noncompliant
+#                       ^^^^^^^^^^^
+
+
+T = TypeVar("T")
+P = ParamSpec("P")
+UserId2 = NewType("UserId2", int)
+
+MyType2 = TypeVar("MyType2")
+MyParams2 = ParamSpec("MyParams2")
+MyInt2 = NewType("MyInt2", int)
+
+T_co2 = TypeVar("T_co2", covariant=True)
+T_contra2 = TypeVar("T_contra2", contravariant=True)
+
+T_bound = TypeVar("T_bound", bound=int)
+T_constrained = TypeVar("T_constrained", int, str)
+
+AnotherType2 = typing.TypeVar("AnotherType2")
+MyPS2 = typing.ParamSpec("MyPS2")
+MyNT2 = typing.NewType("MyNT2", str)
+
+MyExtType2 = typing_extensions.TypeVar("MyExtType2")
+MyExtParams2 = typing_extensions.ParamSpec("MyExtParams2")
+MyExtInt2 = typing_extensions.NewType("MyExtInt2", int)
+
+T_alias = TV("T_alias")
+P_alias = PS("P_alias")
+NT_alias = NT("NT_alias", int)
+ExtT_alias = ExtTV("ExtT_alias")
+ExtP_alias = ExtPS("ExtP_alias")
+ExtNT_alias = ExtNewType("ExtNT_alias", int)
+
+MySingleQuoteType2 = TypeVar('MySingleQuoteType2')
+
+MyRawType = TypeVar(r"MyRawType")
+MyTripleType = TypeVar("""MyTripleType""")
+
+MyRawTypeBad = TypeVar(r"WrongRaw")  # Noncompliant {{Rename this string to match the variable name "MyRawTypeBad".}}
+#                      ^^^^^^^^^^^
+MyTripleTypeBad = TypeVar("""WrongTriple""")  # Noncompliant {{Rename this string to match the variable name "MyTripleTypeBad".}}
+#                         ^^^^^^^^^^^^^^^^^
+
+_name = "T"
+T_dynamic = TypeVar(_name)
+
+T_computed = TypeVar("T".lower())
+
+result = list(TypeVar("T"))
+
+
+def make_typevar():
+    return TypeVar("T")
+
+
+def compliant_inside_function():
+    InnerT = TypeVar("InnerT")
+    InnerP = ParamSpec("InnerP")
+    InnerNT = NewType("InnerNT", int)
+
+
+class CompliantGenericClass:
+    ClassT = TypeVar("ClassT")
+    ClassP = ParamSpec("ClassP")
+    ClassNT = NewType("ClassNT", int)
+
+
+try:
+    T_noargs = TypeVar()  # noqa
+except TypeError:
+    pass
+
+_kwargs = {"covariant": True}
+T_unpacked = TypeVar(**_kwargs)
+
+A = B = TypeVar("A")
+
+C, D = TypeVar("C"), TypeVar("D")
+
+(G, H) = TypeVar("T")
+
+I, J = TypeVar("T")
+
+_d = {}
+_d["key"] = TypeVar("T")
+
+
+class _Holder:
+    pass
+
+
+_obj = _Holder()
+_obj.attr = TypeVar("T")
+
+_flag = True
+T_ternary = TypeVar("T_ternary") if _flag else TypeVar("T_ternary")
+
+E, F = TypeVar("T"), TypeVar("T")
+
+T_keyword_match = TypeVar(name="T_keyword_match")
+T_keyword_mismatch = TypeVar(name="WrongName")  # Noncompliant {{Rename this string to match the variable name "T_keyword_mismatch".}}
+#                                 ^^^^^^^^^^^
+
+import typing as _typing
+# Annotated assignments (AnnotatedAssignment node) are not AssignmentStatement, so they are skipped.
+T_annotated: _typing.TypeAlias = TypeVar("WrongName")
+
+if walrus := TypeVar("T"):
+    pass
diff --git a/python-checks/src/test/resources/checks/unconditionalAssertion/unconditionalAssertion.py b/python-checks/src/test/resources/checks/unconditionalAssertion/unconditionalAssertion.py
index 04227b1fd4..6ace5f2087 100644
--- a/python-checks/src/test/resources/checks/unconditionalAssertion/unconditionalAssertion.py
+++ b/python-checks/src/test/resources/checks/unconditionalAssertion/unconditionalAssertion.py
@@ -59,6 +59,8 @@ def test_assert_statement_used_for_test_failure(self):
         # Should be raised by another rule
         assert False
         assert 0
+        assert 9223372036854775808  # Noncompliant {{Replace this expression; its boolean value is constant.}}
+    #          ^^^^^^^^^^^^^^^^^^^
 
 
     def test_constant_assert_true_with_unpacking(self):
diff --git a/python-checks/src/test/resources/checks/undefinedSymbols/undefinedSymbols.py b/python-checks/src/test/resources/checks/undefinedSymbols/undefinedSymbols.py
index 59c339f5d6..2778508708 100644
--- a/python-checks/src/test/resources/checks/undefinedSymbols/undefinedSymbols.py
+++ b/python-checks/src/test/resources/checks/undefinedSymbols/undefinedSymbols.py
@@ -163,6 +163,30 @@ def from_class_def(self):
     def unknow_generic(self):
         a: list[X] = ... # Noncompliant
 
+class GenericClassBuiltinBound[ItemType, ItemTypeId: str]:
+    pass
+
+class BaseBound:
+    pass
+
+class GenericClassUserDefinedBound[FooT: BaseBound]:
+    pass
+
+class UserBase:
+    pass
+
+class UserGeneric[UBased: UserBase]:
+    def __init__(self, value: UBased) -> None:
+        self.value = value
+
+from collections.abc import Callable
+type Validator[V] = Callable[[V], V]
+
+class Serializable:
+    pass
+
+type SerializableList[S: Serializable] = list[S]
+
 # FP with python 2 syntax for exception handling
 try:
   ""
diff --git a/python-checks/src/test/resources/checks/unionTypeExpression.py b/python-checks/src/test/resources/checks/unionTypeExpression.py
index 8085c69351..fe617cda0c 100644
--- a/python-checks/src/test/resources/checks/unionTypeExpression.py
+++ b/python-checks/src/test/resources/checks/unionTypeExpression.py
@@ -1,4 +1,4 @@
-from typing import Union
+from typing import Annotated, Union
 from typing import Union as u
 import typing
 import typing as t
@@ -40,8 +40,7 @@ def instance_method() -> Union[int, str]: # Noncompliant
         pass
 
 
-# There is no clear recommendation on this case, so we will just not handle them for the time being.
-def union_in_generic_type() -> list[Union[int, str]]: # FN
+def union_in_generic_type() -> list[Union[int, str]]: # Noncompliant
     pass
 
 def ok(param: int | str) -> int | str:
@@ -66,3 +65,13 @@ def unknown_return_type() -> unknown:
 
 def unknown_return_type_subscript() -> unknown[int, str]:
     pass
+
+variable: Annotated[int | str, "metadata"]
+
+top_level: Annotated[float | bytes, "info"]
+
+def annotated_param(value: Annotated[int | str, "description"]) -> None:
+    pass
+
+def annotated_return() -> Annotated[int | str, "result"]:
+    return 42
diff --git a/python-checks/src/test/resources/checks/unnecessarySubscriptReversal.py b/python-checks/src/test/resources/checks/unnecessarySubscriptReversal.py
index 8ac6958742..a373d2b5ef 100644
--- a/python-checks/src/test/resources/checks/unnecessarySubscriptReversal.py
+++ b/python-checks/src/test/resources/checks/unnecessarySubscriptReversal.py
@@ -35,6 +35,7 @@ def case4():
   set(data[::-2])
   set(data[::1])
   set(data[::-b])
+  sorted(data[::-9223372036854775808])  # Compliant (stride literal does not parse to long)
   list(data[::-1])
 
 def case5():
diff --git a/python-checks/src/test/resources/checks/unusedFunctionParameter/django/middleware.py b/python-checks/src/test/resources/checks/unusedFunctionParameter/django/middleware.py
new file mode 100644
index 0000000000..b1285ccdce
--- /dev/null
+++ b/python-checks/src/test/resources/checks/unusedFunctionParameter/django/middleware.py
@@ -0,0 +1,32 @@
+from django.utils.deprecation import MiddlewareMixin
+
+
+class MyMiddleware(MiddlewareMixin):
+    def process_request(self, request):  # Compliant - Django middleware hook
+        print("logging")
+
+    def process_exception(
+        self, request, exception
+    ):  # Compliant - Django middleware hook
+        print("logging")
+
+    def process_view(
+        self, request, view_func, view_args, view_kwargs
+    ):  # Compliant - Django middleware hook
+        print("logging")
+
+    def process_template_response(
+        self, request, response
+    ):  # Compliant - Django middleware hook
+        print("logging")
+
+    def some_other_method(self, foo):  # Noncompliant
+        print("logging")
+
+
+class NotAMiddleware:
+    def process_request(self, request):  # Noncompliant
+        print("logging")
+
+    def process_exception(self, request, exception):  # Noncompliant 2
+        print("logging")
diff --git a/python-checks/src/test/resources/checks/unusedFunctionParameter/unusedFunctionParameter.py b/python-checks/src/test/resources/checks/unusedFunctionParameter/unusedFunctionParameter.py
index 9a24014f5d..c8de141912 100644
--- a/python-checks/src/test/resources/checks/unusedFunctionParameter/unusedFunctionParameter.py
+++ b/python-checks/src/test/resources/checks/unusedFunctionParameter/unusedFunctionParameter.py
@@ -228,3 +228,10 @@ class LocalClassWithAnnotatedMember:
 class LocalClassChild(LocalClassWithAnnotatedMember):
   def my_member(self, param, other_param): # OK, respecting contract defined in parent
     print("Execute")
+
+
+from django.views import generic
+
+class TestDjango(generic.DetailView):
+    def get_object(self, queryset=None):
+        print("Should not raise")
diff --git a/python-checks/src/test/resources/checks/useOfAnyAsTypeHintCheck/useOfAnyAsTypeHint.py b/python-checks/src/test/resources/checks/useOfAnyAsTypeHintCheck/useOfAnyAsTypeHint.py
index 1571aef0b1..923b178c13 100644
--- a/python-checks/src/test/resources/checks/useOfAnyAsTypeHintCheck/useOfAnyAsTypeHint.py
+++ b/python-checks/src/test/resources/checks/useOfAnyAsTypeHintCheck/useOfAnyAsTypeHint.py
@@ -126,3 +126,26 @@ class LocalClassWithAnnotatedMember:
 class LocalClassChild(LocalClassWithAnnotatedMember):
   def my_member(self, param: Any) -> Any: # OK, defined in parent
     ...
+
+# Variadic parameters (*args, **kwargs) should not raise issues
+def function_with_args(*args: Any) -> None:  # Compliant
+    pass
+
+def function_with_kwargs(**kwargs: Any) -> None:  # Compliant
+    pass
+
+def function_with_both(*some_args: Any, **kwargs: Any) -> None:  # Compliant
+    pass
+
+def function_with_mixed(param: Any, *args: Any, **kwargs: Any) -> str:  # Noncompliant
+    pass
+
+class ClassWithVariadicMethods:
+    def method_with_args(self, *args: Any) -> None:  # Compliant
+        pass
+
+    def method_with_kwargs(self, **kwargs: Any) -> None:  # Compliant
+        pass
+
+    def method_with_both(self, param: Any, *args: Any, **kwargs: Any) -> Any:  # Noncompliant 2
+        pass
diff --git a/python-checks/src/test/resources/checks/useStartsWithEndsWithCheck.py b/python-checks/src/test/resources/checks/useStartsWithEndsWithCheck.py
index eaaafade94..a374d66c10 100644
--- a/python-checks/src/test/resources/checks/useStartsWithEndsWithCheck.py
+++ b/python-checks/src/test/resources/checks/useStartsWithEndsWithCheck.py
@@ -61,6 +61,7 @@ def f():
   foobar[3:6:0x1] == 'bar' # Same
   foobar[-3:] == 'bar' # Noncompliant {{Use `endswith` here.}}
   foobar[:-3] == 'foo' # Noncompliant {{Use `startswith` here.}}
+  foobar[::9223372036854775808] == 'foo'  # Compliant (stride literal: isIntLiteralEqualTo handles NFE)
 
   # If an index is not a plain number, we can not say for sure if it is negative/positive. Hence, we should suggest startswith and endswith
   foobar[:unknownA()] == 'foo' # Noncompliant {{Use `startswith` here.}}
diff --git a/python-checks/src/test/resources/checks/uselessStatement/uselessStatement.py b/python-checks/src/test/resources/checks/uselessStatement/uselessStatement.py
index 7da337a39f..c6abbcc636 100644
--- a/python-checks/src/test/resources/checks/uselessStatement/uselessStatement.py
+++ b/python-checks/src/test/resources/checks/uselessStatement/uselessStatement.py
@@ -6,6 +6,8 @@ class MyClass:
 
     def method(self): ...
 
+    def __eq__(self, other): ...
+
     @classmethod
     def class_method(cls): ...
 
@@ -149,7 +151,7 @@ def airflow_ignore_context_false_negative():
         ping = HttpOperator(endpoint="http://example.com/update/")
         download = HttpOperator(endpoint="http://example.com/download/")
         upload = HttpOperator(endpoint="http://example.com/upload/")
-        ping # Noncompliant
+        ping
         download >> upload
 
 from airflow.decorators import dag
@@ -165,7 +167,7 @@ def airflow_decorator_multiple_statements():
     download = HttpOperator(endpoint="http://example.com/download/")
     upload = HttpOperator(endpoint="http://example.com/upload/")
     download >> upload
-    ping # Noncompliant
+    ping
     ping >> upload
 
 def airflow_nested_with():
@@ -174,7 +176,7 @@ def airflow_nested_with():
             ping = HttpOperator(endpoint="http://example.com/update/")
             download = HttpOperator(endpoint="http://example.com/download/")
             upload = HttpOperator(endpoint="http://example.com/upload/")
-            ping # Noncompliant
+            ping
             download >> upload
 
 @dag
@@ -189,3 +191,19 @@ def airflow_ignore_context_not_operator():
         some_other_var = True
         some_var # Noncompliant
         some_other_var
+
+from airflow.providers.amazon.aws.operators.ecs import EcsRunTaskOperator
+from airflow.models.baseoperator import BaseOperator as AirflowBaseOperator
+
+_module_dag = DAG(dag_id="example_dag", schedule_interval=None)
+_ecs_task = EcsRunTaskOperator(task_id="generate_yaml", dag=_module_dag)
+_ecs_task
+
+_http_task = HttpOperator(task_id="http", endpoint="/", dag=_module_dag)
+_http_task
+
+class _CustomOperator(AirflowBaseOperator):
+    def execute(self, context): pass
+
+_custom_task = _CustomOperator(task_id="custom", dag=_module_dag)
+_custom_task
diff --git a/python-checks/src/test/resources/checks/uselessStatement/uselessStatementMarimo.py b/python-checks/src/test/resources/checks/uselessStatement/uselessStatementMarimo.py
new file mode 100644
index 0000000000..d4e703152d
--- /dev/null
+++ b/python-checks/src/test/resources/checks/uselessStatement/uselessStatementMarimo.py
@@ -0,0 +1,65 @@
+import marimo
+
+app = marimo.App()
+
+
+@app.cell
+def _(combined_df):
+    combined_df
+    return
+
+
+@app.cell
+def _(_fig):
+    _fig
+    return
+
+
+@app.cell(hide_code=True)
+def _(result_df):
+    result_df
+    return
+
+
+@app.cell
+def _(df):
+    df
+
+
+@app.cell
+def _(x, y):
+    x  # Noncompliant
+    y
+    return
+
+
+@app.cell
+def _(df):
+    df
+    if True:  # control flow after cell output
+        pass
+
+
+@app.cell
+def _(x, y):
+    x  # Noncompliant
+    if True:  # control flow after non-last expression
+        pass
+    y
+
+
+@app.cell
+def _(x):
+    if True:
+        x  # Noncompliant
+
+
+@app.function
+def helper(x):
+    x  # Noncompliant
+    return x
+
+
+def not_marimo(x):
+    x  # Noncompliant
+    return x
diff --git a/python-checks/src/test/resources/checks/verifiedSslTlsCertificateCheck.py b/python-checks/src/test/resources/checks/verifiedSslTlsCertificateCheck.py
index f112e54472..8cff3675f3 100644
--- a/python-checks/src/test/resources/checks/verifiedSslTlsCertificateCheck.py
+++ b/python-checks/src/test/resources/checks/verifiedSslTlsCertificateCheck.py
@@ -89,6 +89,7 @@ def requestsTests():
   #                                                        ^^^^^
   requests.request('GET', 'https://example.domain', verify=range(0)) # Noncompliant {{Enable server certificate validation on this SSL/TLS connection.}}
   #                                                        ^^^^^^^^
+  requests.request('GET', 'https://example.domain', verify=range(9223372036854775808)) # Compliant (stop literal does not parse to long)
   requests.request(verify=False, method='GET', url='https://example.domain') # Noncompliant {{Enable server certificate validation on this SSL/TLS connection.}}
   #                       ^^^^^
 
diff --git a/python-commons/pom.xml b/python-commons/pom.xml
index 8ca5c3f699..50f33151cc 100644
--- a/python-commons/pom.xml
+++ b/python-commons/pom.xml
@@ -6,7 +6,7 @@
   
     org.sonarsource.python
     python
-    5.19-SNAPSHOT
+    5.30-SNAPSHOT
   
 
   python-commons
@@ -22,12 +22,6 @@
       org.sonarsource.sonarlint.core
       sonarlint-plugin-api
     
-    
-      org.sonarsource.sonarqube
-      sonar-plugin-api-impl
-      ${sonar.version}
-      test
-    
     
       ${project.groupId}
       python-frontend
@@ -38,6 +32,10 @@
       python-checks
       ${project.version}
     
+    
+      com.google.code.gson
+      gson
+    
     
       org.sonarsource.analyzer-commons
       sonar-analyzer-commons
@@ -96,6 +94,16 @@
       sonar-plugin-api-test-fixtures
       test
     
+    
+      org.sonarsource.scanner.engine
+      plugin-api-scanner-impl
+      test
+    
+    
+      org.sonarsource.scanner.engine
+      sensor-test-fixtures
+      test
+    
     
       org.junit.jupiter
       junit-jupiter
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/AIQualityProfile.java b/python-commons/src/main/java/org/sonar/plugins/python/AIQualityProfile.java
new file mode 100644
index 0000000000..b4096cc7e8
--- /dev/null
+++ b/python-commons/src/main/java/org/sonar/plugins/python/AIQualityProfile.java
@@ -0,0 +1,56 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python;
+
+import org.sonar.api.server.profile.BuiltInQualityProfilesDefinition;
+import org.sonar.plugins.python.editions.RepositoryInfoProvider;
+import org.sonar.plugins.python.editions.RepositoryInfoProvider.RepositoryInfo;
+import org.sonarsource.analyzer.commons.BuiltInQualityProfileJsonLoader;
+
+public class AIQualityProfile implements BuiltInQualityProfilesDefinition {
+
+  static final String PROFILE_NAME = "Sonar agentic AI";
+
+  private final RepositoryInfoProvider[] editionMetadataProviders;
+
+  public AIQualityProfile(RepositoryInfoProvider[] editionMetadataProviders) {
+    this.editionMetadataProviders = editionMetadataProviders;
+  }
+
+  @Override
+  public void define(Context context) {
+    NewBuiltInQualityProfile profile = context.createBuiltInQualityProfile(PROFILE_NAME, Python.KEY);
+
+    for (RepositoryInfoProvider repositoryInfoProvider : editionMetadataProviders) {
+      registerRulesForEdition(repositoryInfoProvider, profile);
+    }
+
+    PythonProfile.getSecurityRuleKeys()
+      .forEach(key -> profile.activateRule(key.repository(), key.rule()));
+    PythonProfile.getDataflowBugDetectionRuleKeys()
+      .forEach(key -> profile.activateRule(key.repository(), key.rule()));
+    PythonProfile.getArchitectureRuleKeys()
+      .forEach(key -> profile.activateRule(key.repository(), key.rule()));
+    profile.done();
+  }
+
+  private static void registerRulesForEdition(RepositoryInfoProvider repositoryInfoProvider, NewBuiltInQualityProfile profile) {
+    RepositoryInfo repositoryInfo = repositoryInfoProvider.getAIProfileInfo();
+    BuiltInQualityProfileJsonLoader.load(profile, repositoryInfo.repositoryKey(), repositoryInfo.profileLocation());
+    profile.activeRules().removeIf(rule -> repositoryInfo.disabledRules().contains(rule.ruleKey()));
+  }
+}
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/AbstractPythonRuleRepository.java b/python-commons/src/main/java/org/sonar/plugins/python/AbstractPythonRuleRepository.java
index ac46697a2f..e96b321903 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/AbstractPythonRuleRepository.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/AbstractPythonRuleRepository.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/DependencyTelemetrySensor.java b/python-commons/src/main/java/org/sonar/plugins/python/DependencyTelemetrySensor.java
index 32fb774b22..bd49842b29 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/DependencyTelemetrySensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/DependencyTelemetrySensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/EmptyReportException.java b/python-commons/src/main/java/org/sonar/plugins/python/EmptyReportException.java
index 7e75aad193..e4b2a3afe9 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/EmptyReportException.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/EmptyReportException.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/ExternalIssuesSensor.java b/python-commons/src/main/java/org/sonar/plugins/python/ExternalIssuesSensor.java
index 5163243aa4..eac0638265 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/ExternalIssuesSensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/ExternalIssuesSensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/IPynb.java b/python-commons/src/main/java/org/sonar/plugins/python/IPynb.java
index 8eb895d545..662d9240d0 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/IPynb.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/IPynb.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/IPynbAIQualityProfile.java b/python-commons/src/main/java/org/sonar/plugins/python/IPynbAIQualityProfile.java
new file mode 100644
index 0000000000..040a5dca69
--- /dev/null
+++ b/python-commons/src/main/java/org/sonar/plugins/python/IPynbAIQualityProfile.java
@@ -0,0 +1,50 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python;
+
+import org.sonar.api.server.profile.BuiltInQualityProfilesDefinition;
+import org.sonar.plugins.python.editions.RepositoryInfoProvider;
+import org.sonar.plugins.python.editions.RepositoryInfoProvider.RepositoryInfo;
+import org.sonarsource.analyzer.commons.BuiltInQualityProfileJsonLoader;
+
+public class IPynbAIQualityProfile implements BuiltInQualityProfilesDefinition {
+
+  static final String PROFILE_NAME = "Sonar agentic AI";
+
+  private final RepositoryInfoProvider[] editionMetadataProviders;
+
+  public IPynbAIQualityProfile(RepositoryInfoProvider[] editionMetadataProviders) {
+    this.editionMetadataProviders = editionMetadataProviders;
+  }
+
+  @Override
+  public void define(Context context) {
+    NewBuiltInQualityProfile profile = context.createBuiltInQualityProfile(PROFILE_NAME, IPynb.KEY);
+
+    for (RepositoryInfoProvider repositoryInfoProvider : editionMetadataProviders) {
+      registerRulesForEdition(repositoryInfoProvider, profile);
+    }
+
+    profile.done();
+  }
+
+  private static void registerRulesForEdition(RepositoryInfoProvider repositoryInfoProvider, NewBuiltInQualityProfile profile) {
+    RepositoryInfo repositoryInfo = repositoryInfoProvider.getIPynbAIProfileInfo();
+    BuiltInQualityProfileJsonLoader.load(profile, repositoryInfo.repositoryKey(), repositoryInfo.profileLocation());
+    profile.activeRules().removeIf(rule -> repositoryInfo.disabledRules().contains(rule.ruleKey()));
+  }
+}
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/IPynbProfile.java b/python-commons/src/main/java/org/sonar/plugins/python/IPynbProfile.java
index 521f4b6653..9a8790a026 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/IPynbProfile.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/IPynbProfile.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/IPynbRuleRepository.java b/python-commons/src/main/java/org/sonar/plugins/python/IPynbRuleRepository.java
index f04c0b6840..24111a049d 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/IPynbRuleRepository.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/IPynbRuleRepository.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/IPynbSensor.java b/python-commons/src/main/java/org/sonar/plugins/python/IPynbSensor.java
index 2826914f36..2cfe7c7203 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/IPynbSensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/IPynbSensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -31,8 +31,6 @@
 import org.sonar.api.batch.sensor.SensorDescriptor;
 import org.sonar.api.issue.NoSonarFilter;
 import org.sonar.api.measures.FileLinesContextFactory;
-import org.sonar.plugins.python.api.ProjectPythonVersion;
-import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.plugins.python.api.caching.CacheContext;
 import org.sonar.plugins.python.architecture.DummyArchitectureCallback;
 import org.sonar.plugins.python.editions.OpenSourceRepositoryInfoProvider;
@@ -42,13 +40,12 @@
 import org.sonar.plugins.python.indexer.SonarQubePythonIndexer;
 import org.sonar.plugins.python.nosonar.NoSonarLineInfoCollector;
 import org.sonar.plugins.python.telemetry.SensorTelemetryStorage;
+import org.sonar.plugins.python.warnings.AnalysisWarningsWrapper;
 import org.sonar.plugins.python.telemetry.TelemetryMetricKey;
 import org.sonar.python.caching.CacheContextImpl;
 import org.sonar.python.parser.PythonParser;
 import org.sonar.python.project.config.ProjectConfigurationBuilder;
 
-import static org.sonar.plugins.python.api.PythonVersionUtils.PYTHON_VERSION_KEY;
-
 public final class IPynbSensor implements Sensor {
 
   private final PythonChecks checks;
@@ -113,13 +110,9 @@ public void describe(SensorDescriptor descriptor) {
   public void execute(SensorContext context) {
     Instant sensorStartTime = Instant.now();
     List pythonFiles = getInputFiles(context);
-    var pythonVersions = context.config().getStringArray(PYTHON_VERSION_KEY);
-    if (pythonVersions.length != 0) {
-      ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.fromStringArray(pythonVersions));
-    }
     if (isInSonarLintRuntime(context)) {
       PythonScanner scanner = new PythonScanner(context, checks, fileLinesContextFactory, noSonarFilter, PythonParser::createIPythonParser,
-        indexer, new DummyArchitectureCallback(), noSonarLineInfoCollector);
+        indexer, new DummyArchitectureCallback(), noSonarLineInfoCollector, new AnalysisWarningsWrapper());
       scanner.execute(pythonFiles, context);
     } else {
       processNotebooksFiles(pythonFiles, context);
@@ -139,7 +132,7 @@ private void processNotebooksFiles(List pythonFiles, SensorCont
     CacheContext cacheContext = CacheContextImpl.dummyCache();
     PythonIndexer pythonIndexer = new SonarQubePythonIndexer(pythonFiles, cacheContext, context, projectConfigurationBuilder);
     PythonScanner scanner = new PythonScanner(context, checks, fileLinesContextFactory, noSonarFilter, PythonParser::createIPythonParser,
-      pythonIndexer, new DummyArchitectureCallback(), noSonarLineInfoCollector);
+      pythonIndexer, new DummyArchitectureCallback(), noSonarLineInfoCollector, new AnalysisWarningsWrapper());
     scanner.execute(pythonFiles, context);
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.NOTEBOOK_RECOGNITION_ERROR_KEY, scanner.getRecognitionErrorCount());
     updateDatabricksTelemetry(scanner);
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/IssuesRepository.java b/python-commons/src/main/java/org/sonar/plugins/python/IssuesRepository.java
index 60a9607155..f455fc9892 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/IssuesRepository.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/IssuesRepository.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,6 +18,7 @@
 
 import java.io.File;
 import java.util.ArrayDeque;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.locks.Lock;
@@ -70,6 +71,31 @@ private void save(PythonInputFile inputFile, PythonCheck.PreciseIssue preciseIss
     var primaryLocation = newLocation(inputFile, newIssue, preciseIssue.primaryLocation());
     newIssue.at(primaryLocation);
 
+    addDataFlows(inputFile, newIssue, preciseIssue);
+    addSecondaryLocations(inputFile, newIssue, preciseIssue, primaryLocation);
+
+    handleQuickFixes(inputFile.wrappedFile(), ruleKey, newIssue, preciseIssue);
+
+    save(newIssue);
+  }
+
+  private void addDataFlows(PythonInputFile inputFile, NewIssue newIssue, PythonCheck.PreciseIssue preciseIssue) {
+    for (var flow : preciseIssue.flows()) {
+      List flowLocations = new ArrayList<>();
+      for (var location : flow.locations()) {
+        NewIssueLocation newLocation = resolveLocation(inputFile, newIssue, location);
+        if (newLocation != null) {
+          flowLocations.add(newLocation);
+        }
+      }
+      if (!flowLocations.isEmpty()) {
+        newIssue.addFlow(flowLocations, NewIssue.FlowType.DATA, flow.description());
+      }
+    }
+  }
+
+  private void addSecondaryLocations(PythonInputFile inputFile, NewIssue newIssue, PythonCheck.PreciseIssue preciseIssue,
+                                      NewIssueLocation primaryLocation) {
     var secondaryLocationsFlow = new ArrayDeque();
     for (var secondaryLocation : preciseIssue.secondaryLocations()) {
       String fileId = secondaryLocation.fileId();
@@ -88,10 +114,19 @@ private void save(PythonInputFile inputFile, PythonCheck.PreciseIssue preciseIss
       secondaryLocationsFlow.addFirst(primaryLocation);
       newIssue.addFlow(secondaryLocationsFlow);
     }
+  }
 
-    handleQuickFixes(inputFile.wrappedFile(), ruleKey, newIssue, preciseIssue);
-
-    save(newIssue);
+  @CheckForNull
+  private NewIssueLocation resolveLocation(PythonInputFile defaultInputFile, NewIssue newIssue, IssueLocation location) {
+    String fileId = location.fileId();
+    if (fileId == null) {
+      return newLocation(defaultInputFile, newIssue, location);
+    }
+    InputFile issueLocationFile = component(fileId, context);
+    if (issueLocationFile == null) {
+      return null;
+    }
+    return newLocation(new PythonInputFileImpl(issueLocationFile), newIssue, location);
   }
 
   private void save(NewIssue newIssue) {
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/MeasuresRepository.java b/python-commons/src/main/java/org/sonar/plugins/python/MeasuresRepository.java
index c12adfeca1..97c72cee2b 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/MeasuresRepository.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/MeasuresRepository.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -61,6 +61,14 @@ public void save(PythonInputFile inputFile, PythonVisitorContext visitorContext)
     }
   }
 
+  public void saveNclocForTestFile(PythonInputFile inputFile, PythonVisitorContext visitorContext) {
+    if (!isInSonarLint) {
+      FileMetrics fileMetrics = new FileMetrics(visitorContext, isNotebook(inputFile));
+      int linesOfCode = fileMetrics.fileLinesVisitor().getLinesOfCode().size();
+      saveMetricOnFile(inputFile, CoreMetrics.NCLOC, linesOfCode);
+    }
+  }
+
   private void saveInternal(PythonInputFile inputFile, PythonVisitorContext visitorContext) {
     FileMetrics fileMetrics = new FileMetrics(visitorContext, isNotebook(inputFile));
     FileLinesVisitor fileLinesVisitor = fileMetrics.fileLinesVisitor();
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/MultiFileProgressReport.java b/python-commons/src/main/java/org/sonar/plugins/python/MultiFileProgressReport.java
index f2760e2125..782d3645d8 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/MultiFileProgressReport.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/MultiFileProgressReport.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/NewSymbolsCollector.java b/python-commons/src/main/java/org/sonar/plugins/python/NewSymbolsCollector.java
index 2c0b664fdc..9dccf6302f 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/NewSymbolsCollector.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/NewSymbolsCollector.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/Python.java b/python-commons/src/main/java/org/sonar/plugins/python/Python.java
index b79e552332..769d7bed52 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/Python.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/Python.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/PythonChecks.java b/python-commons/src/main/java/org/sonar/plugins/python/PythonChecks.java
index 1c37578b2b..cc8ee04ebf 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/PythonChecks.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/PythonChecks.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/PythonExtensionKeys.java b/python-commons/src/main/java/org/sonar/plugins/python/PythonExtensionKeys.java
index 61f26db295..e31096c2ad 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/PythonExtensionKeys.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/PythonExtensionKeys.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/PythonExtensions.java b/python-commons/src/main/java/org/sonar/plugins/python/PythonExtensions.java
index bd67a8950e..a9f4efa224 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/PythonExtensions.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/PythonExtensions.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -41,6 +41,7 @@
 import org.sonar.plugins.python.mypy.MypySensor;
 import org.sonar.plugins.python.nosonar.NoSonarIssueFilter;
 import org.sonar.plugins.python.nosonar.NoSonarLineInfoCollector;
+import org.sonar.plugins.python.nosonar.SecurityRuleKeyProvider;
 import org.sonar.python.project.config.ProjectConfigurationBuilder;
 import org.sonar.plugins.python.pylint.PylintRulesDefinition;
 import org.sonar.plugins.python.pylint.PylintSensor;
@@ -69,6 +70,7 @@ public static void addCommonExtensions(Plugin.Context context) {
     context.addExtensions(
       ProjectConfigurationBuilder.class,
       NoSonarLineInfoCollector.class,
+      SecurityRuleKeyProvider.class,
       NoSonarIssueFilter.class,
       buildPythonSuffix(),
       buildIpynbPythonSuffix(),
@@ -76,6 +78,7 @@ public static void addCommonExtensions(Plugin.Context context) {
 
       Python.class,
       PythonProfile.class,
+      AIQualityProfile.class,
 
       PythonSensor.class,
       PythonRuleRepository.class,
@@ -88,6 +91,7 @@ public static void addCommonExtensions(Plugin.Context context) {
       
       IPynb.class,
       IPynbProfile.class,
+      IPynbAIQualityProfile.class,
       IPynbSensor.class,
       IPynbRuleRepository.class,
       OpenSourceRepositoryInfoProvider.class
@@ -237,7 +241,7 @@ private static PropertyDefinition buildPythonVersion() {
     return PropertyDefinition.builder(PYTHON_VERSION_KEY)
       .index(12)
       .name("Python versions")
-      .description("Comma-separated list of Python versions this project is compatible with.")
+      .description("Comma-separated list of Python versions or version specifiers this project is compatible with.")
       .multiValues(true)
       .category(PYTHON_CATEGORY)
       .subCategory(GENERAL)
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/PythonHighlighter.java b/python-commons/src/main/java/org/sonar/plugins/python/PythonHighlighter.java
index 34ba05a12b..a1fe591922 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/PythonHighlighter.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/PythonHighlighter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/PythonProfile.java b/python-commons/src/main/java/org/sonar/plugins/python/PythonProfile.java
index 2e9f7d5e2f..a797b193ec 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/PythonProfile.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/PythonProfile.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/PythonReportSensor.java b/python-commons/src/main/java/org/sonar/plugins/python/PythonReportSensor.java
index e384d0b36f..29530fbdce 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/PythonReportSensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/PythonReportSensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/PythonRuleRepository.java b/python-commons/src/main/java/org/sonar/plugins/python/PythonRuleRepository.java
index 32f783b2a0..f6f4c9e8f8 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/PythonRuleRepository.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/PythonRuleRepository.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/PythonScanner.java b/python-commons/src/main/java/org/sonar/plugins/python/PythonScanner.java
index 579b3c687c..ba8262b842 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/PythonScanner.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/PythonScanner.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,6 +19,7 @@
 import com.sonar.sslr.api.AstNode;
 import com.sonar.sslr.api.RecognitionException;
 import java.io.File;
+import javax.annotation.Nullable;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -32,6 +33,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Consumer;
 import java.util.function.Supplier;
 import java.util.regex.Pattern;
 import org.slf4j.Logger;
@@ -47,20 +49,28 @@
 import org.sonar.plugins.python.api.PythonInputFileContext;
 import org.sonar.plugins.python.api.PythonSubscriptionCheck;
 import org.sonar.plugins.python.api.PythonVisitorContext;
+import org.sonar.plugins.python.api.ProjectPythonVersion;
+import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.plugins.python.api.internal.EndOfAnalysis;
 import org.sonar.plugins.python.api.tree.FileInput;
 import org.sonar.plugins.python.cpd.PythonCpdAnalyzer;
 import org.sonar.plugins.python.indexer.PythonIndexer;
 import org.sonar.plugins.python.nosonar.NoSonarLineInfoCollector;
+import org.sonar.plugins.python.telemetry.collectors.ImportsTelemetry;
+import org.sonar.plugins.python.telemetry.collectors.ImportsTelemetryCollector;
 import org.sonar.plugins.python.telemetry.collectors.TestFileTelemetry;
 import org.sonar.plugins.python.telemetry.collectors.TestFileTelemetryCollector;
 import org.sonar.plugins.python.telemetry.collectors.TypeInferenceTelemetry;
 import org.sonar.plugins.python.telemetry.collectors.TypeInferenceTelemetryCollector;
+import org.sonar.plugins.python.warnings.AnalysisWarningsWrapper;
 import org.sonar.python.IPythonLocation;
 import org.sonar.python.SubscriptionVisitor;
 import org.sonar.python.parser.PythonParser;
 import org.sonar.python.tree.IPythonTreeMaker;
 import org.sonar.python.tree.PythonTreeMaker;
+import org.sonar.python.types.TypeShed;
+
+import static org.sonar.plugins.python.api.PythonVersionUtils.PYTHON_VERSION_KEY;
 
 public class PythonScanner extends Scanner {
 
@@ -85,15 +95,32 @@ public class PythonScanner extends Scanner {
   private final Lock lock;
   private final TypeInferenceTelemetryCollector typeInferenceTelemetryCollector;
   private final TestFileTelemetryCollector testFileTelemetryCollector;
+  private final ImportsTelemetryCollector importsTelemetryCollector;
+  private final List> telemetryCollectors;
+  private final boolean testSourcesConfigured;
+  private final PythonTestFileClassifier testFileClassifier;
+  private final AnalysisWarningsWrapper analysisWarnings;
+  private final AtomicBoolean heuristicWarningEmitted = new AtomicBoolean(false);
+  private volatile int filesScannedWithCache = 0;
+  static final String UNSET_SONAR_TESTS_WARNING = "SonarPython detected files that look like test code " +
+    "but 'sonar.tests' is not configured. Rules targeting production code were not executed on these files. " +
+    "Configure 'sonar.tests' in your project properties for a more accurate analysis.";
 
   public PythonScanner(
     SensorContext context, PythonChecks checks, FileLinesContextFactory fileLinesContextFactory, NoSonarFilter noSonarFilter,
-    Supplier parserSupplier, PythonIndexer indexer, PythonFileConsumer architectureCallback, NoSonarLineInfoCollector noSonarLineInfoCollector) {
+    Supplier parserSupplier, PythonIndexer indexer, PythonFileConsumer architectureCallback,
+    NoSonarLineInfoCollector noSonarLineInfoCollector, AnalysisWarningsWrapper analysisWarnings) {
     super(context);
     this.checks = checks;
     this.parserSupplier = parserSupplier;
     this.indexer = indexer;
     this.noSonarLineInfoCollector = noSonarLineInfoCollector;
+    this.analysisWarnings = analysisWarnings;
+    this.testSourcesConfigured = TestSourceConfiguration.isConfigured(context.config());
+    this.testFileClassifier = new PythonTestFileClassifier(context.config());
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.fromStringArray(context.config().getStringArray(PYTHON_VERSION_KEY)));
+    TypeShed.setProjectLevelSymbolTable(indexer.projectLevelSymbolTable());
+    TypeShed.resetBuiltinSymbols();
     this.indexer.buildOnce(context);
     this.architectureCallback = architectureCallback;
     this.checksExecutedWithoutParsingByFiles = new ConcurrentHashMap<>();
@@ -108,6 +135,8 @@ public PythonScanner(
     this.measuresRepository = new MeasuresRepository(context, noSonarFilter, fileLinesContextFactory, isInSonarLint(context), noSonarLineInfoCollector, lock);
     this.typeInferenceTelemetryCollector = new TypeInferenceTelemetryCollector();
     this.testFileTelemetryCollector = new TestFileTelemetryCollector();
+    this.importsTelemetryCollector = new ImportsTelemetryCollector();
+    this.telemetryCollectors = List.of(typeInferenceTelemetryCollector::collect, importsTelemetryCollector::collect);
   }
 
   @Override
@@ -125,9 +154,14 @@ protected void scanFile(PythonInputFile inputFile) throws IOException {
     var pythonFile = SonarQubePythonFile.create(inputFile);
     InputFile.Type fileType = inputFile.wrappedFile().type();
     PythonVisitorContext visitorContext = createVisitorContext(inputFile, pythonFile);
+    InputFile.Type effectiveTypeForRules = resolveEffectiveTypeForRules(
+      fileType, visitorContext.isLikelyTestFile());
+    if (!testSourcesConfigured && fileType == InputFile.Type.MAIN) {
+      indexer.writeEffectiveFileType(inputFile.wrappedFile().key(), effectiveTypeForRules);
+    }
 
-    executeChecks(visitorContext, checks.sonarPythonChecks(), fileType, inputFile);
-    executeOtherChecks(inputFile, visitorContext, fileType);
+    executeChecks(visitorContext, checks.sonarPythonChecks(), effectiveTypeForRules, inputFile);
+    executeOtherChecks(inputFile, visitorContext, effectiveTypeForRules);
 
 
     runLockedByRepository(ARCHITECTURE_CALLBACK_LOCK_KEY, () -> architectureCallback.scanFile(visitorContext));
@@ -135,9 +169,13 @@ protected void scanFile(PythonInputFile inputFile) throws IOException {
 
     noSonarLineInfoCollector.collect(pythonFile.key(), visitorContext.rootTree());
 
-    if (fileType == InputFile.Type.MAIN && visitorContext.rootTree() != null) {
-      pushTokens(inputFile, visitorContext);
-      measuresRepository.save(inputFile, visitorContext);
+    if (visitorContext.rootTree() != null) {
+      if (fileType == InputFile.Type.MAIN) {
+        pushTokens(inputFile, visitorContext);
+        measuresRepository.save(inputFile, visitorContext);
+      } else if (fileType == InputFile.Type.TEST) {
+        measuresRepository.saveNclocForTestFile(inputFile, visitorContext);
+      }
     }
 
     var issues = visitorContext.getIssues();
@@ -146,7 +184,7 @@ protected void scanFile(PythonInputFile inputFile) throws IOException {
     if (visitorContext.rootTree() != null && !isInSonarLint(context)) {
       newSymbolsCollector.collect(context.newSymbolTable().onFile(inputFile.wrappedFile()), visitorContext.rootTree());
       pythonHighlighter.highlight(context, visitorContext, inputFile);
-      typeInferenceTelemetryCollector.collect(visitorContext.rootTree());
+      telemetryCollectors.forEach(c -> c.accept(visitorContext.rootTree()));
       testFileTelemetryCollector.collect(visitorContext.rootTree(), fileType, inputFile.wrappedFile().uri().getPath());
     }
 
@@ -159,6 +197,7 @@ private PythonVisitorContext createVisitorContext(PythonInputFile inputFile, Pyt
       AstNode astNode = parserSupplier.get().parse(inputFile.contents());
       PythonTreeMaker treeMaker = getTreeMaker(inputFile);
       FileInput parse = treeMaker.fileInput(astNode);
+      boolean likelyTestFile = isLikelyTestFile(inputFile, parse);
       visitorContext = new PythonVisitorContext.Builder(parse, pythonFile)
         .projectConfiguration(indexer.projectConfig())
         .workingDirectory(getWorkingDirectory(context))
@@ -167,10 +206,11 @@ private PythonVisitorContext createVisitorContext(PythonInputFile inputFile, Pyt
         .typeTable(indexer.projectLevelTypeTable())
         .cacheContext(indexer.cacheContext())
         .sonarProduct(context.runtime().getProduct())
+        .likelyTestFile(likelyTestFile)
         .build();
 
     } catch (RecognitionException e) {
-      visitorContext = new PythonVisitorContext(pythonFile, e, context.runtime().getProduct());
+      visitorContext = new PythonVisitorContext(pythonFile, e, context.runtime().getProduct(), isLikelyTestFile(inputFile, null));
 
       var line = (inputFile.kind() == PythonInputFile.Kind.IPYTHON) ?
         ((GeneratedIPythonFile) inputFile).locationMap().get(e.getLine()).line() : e.getLine();
@@ -188,6 +228,10 @@ private PythonVisitorContext createVisitorContext(PythonInputFile inputFile, Pyt
     return visitorContext;
   }
 
+  private boolean isLikelyTestFile(PythonInputFile inputFile, @Nullable FileInput tree) {
+    return !testSourcesConfigured && testFileClassifier.looksLikeTestFile(inputFile.wrappedFile(), tree);
+  }
+
   private void pushTokens(PythonInputFile inputFile, PythonVisitorContext visitorContext) {
     if (!isInSonarLint(context) && inputFile.kind() == PythonInputFile.Kind.PYTHON) {
       cpdAnalyzer.pushCpdTokens(inputFile.wrappedFile(), visitorContext);
@@ -237,6 +281,11 @@ private static Map getOffsetLocations(PythonInputFile
   @Override
   public boolean scanFileWithoutParsing(PythonInputFile inputFile) {
     InputFile.Type fileType = inputFile.wrappedFile().type();
+    InputFile.Type effectiveTypeForRules = resolveEffectiveTypeForRulesFromCache(
+      fileType, projectRelativePath(inputFile), inputFile.wrappedFile().key());
+    if (effectiveTypeForRules == null) {
+      return false;
+    }
     boolean result = true;
     PythonFile pythonFile = SonarQubePythonFile.create(inputFile.wrappedFile());
     PythonInputFileContext inputFileContext = new PythonInputFileContext(
@@ -247,13 +296,13 @@ public boolean scanFileWithoutParsing(PythonInputFile inputFile) {
       indexer.projectLevelSymbolTable()
     );
 
-    result = scanFileWithoutParsingSonarPython(inputFile, fileType, inputFileContext, result);
+    result = scanFileWithoutParsingSonarPython(inputFile, effectiveTypeForRules, inputFileContext, result);
 
     var atomicResult = new AtomicBoolean(result);
     var otherChecks = checks.noSonarPythonChecks();
     otherChecks.forEach((repositoryKey, repositoryChecks) -> runLockedByRepository(repositoryKey, () -> {
       for (var check : repositoryChecks) {
-        var scanResult = scanFileWithoutParsingNotSonarPython(inputFile, check, fileType, atomicResult.get(), inputFileContext);
+        var scanResult = scanFileWithoutParsingNotSonarPython(inputFile, check, effectiveTypeForRules, atomicResult.get(), inputFileContext);
         atomicResult.set(scanResult);
       }
     }));
@@ -265,7 +314,11 @@ public boolean scanFileWithoutParsing(PythonInputFile inputFile) {
       // We must avoid pushing measures twice due to the risk of duplicate cache key error.
       return false;
     }
-    return restoreAndPushMeasuresIfApplicable(inputFile);
+    boolean success = restoreAndPushMeasuresIfApplicable(inputFile);
+    if (success && !testSourcesConfigured && fileType == InputFile.Type.MAIN) {
+      indexer.writeEffectiveFileType(inputFile.wrappedFile().key(), effectiveTypeForRules);
+    }
+    return success;
   }
 
   private boolean scanFileWithoutParsingNotSonarPython(PythonInputFile inputFile, PythonCheck check, InputFile.Type fileType,
@@ -318,8 +371,53 @@ private void endOfAnalysisForRepository(String repositoryKey, List endOfAnalyses.forEach(c -> c.endOfAnalysis(indexer.cacheContext())));
   }
 
+  private String projectRelativePath(PythonInputFile inputFile) {
+    return context.fileSystem().baseDir().toURI()
+      .relativize(inputFile.wrappedFile().uri())
+      .toString();
+  }
+
+  private boolean isBypassed(InputFile.Type platformType) {
+    return testSourcesConfigured || platformType == InputFile.Type.TEST;
+  }
+
+  private InputFile.Type resolveEffectiveTypeForRules(InputFile.Type platformType, boolean likelyTestFile) {
+    if (isBypassed(platformType)) {
+      return platformType;
+    }
+    if (likelyTestFile) {
+      maybeEmitHeuristicWarning();
+      return InputFile.Type.TEST;
+    }
+    return InputFile.Type.MAIN;
+  }
+
+  @Nullable
+  private InputFile.Type resolveEffectiveTypeForRulesFromCache(InputFile.Type platformType, String filePath, String fileKey) {
+    if (isBypassed(platformType)) {
+      return platformType;
+    }
+    InputFile.Type cached = indexer.readEffectiveFileType(fileKey);
+    if (cached == null) {
+      // Cache entry is missing while the file is unchanged — the cache is in an inconsistent state
+      // This should never happen in normal operation. Fall back to a full parse rather than guessing the type.
+      LOG.debug("No cached effective file type for '{}': triggering full parse", filePath);
+    }
+    return cached;
+  }
+
+  private void maybeEmitHeuristicWarning() {
+    if (heuristicWarningEmitted.compareAndSet(false, true)) {
+      analysisWarnings.addUnique(UNSET_SONAR_TESTS_WARNING);
+    }
+  }
+
   boolean isCheckNotApplicable(PythonCheck pythonCheck, InputFile.Type fileType) {
-    return fileType != InputFile.Type.MAIN && pythonCheck.scope() != PythonCheck.CheckScope.ALL;
+    return switch (pythonCheck.scope()) {
+      case MAIN -> fileType != InputFile.Type.MAIN;
+      case TESTS -> fileType != InputFile.Type.TEST;
+      case ALL -> false;
+    };
   }
 
   // visible for testing
@@ -343,6 +441,7 @@ public boolean canBeScannedWithoutParsing(PythonInputFile inputFile) {
 
   @Override
   protected void reportStatistics(int numSkippedFiles, int numTotalFiles) {
+    filesScannedWithCache = numSkippedFiles;
     LOG.info("""
              The Python analyzer was able to leverage cached data from previous analyses for {} out of {} files. These files were not \
              parsed.""",
@@ -373,6 +472,18 @@ public TestFileTelemetry getTestFileTelemetry() {
     return testFileTelemetryCollector.getTelemetry();
   }
 
+  public ImportsTelemetry getImportsTelemetry() {
+    return importsTelemetryCollector.getTelemetry();
+  }
+
+  public boolean wasTestFileHeuristicTriggered() {
+    return heuristicWarningEmitted.get();
+  }
+
+  public int getFilesScannedWithCache() {
+    return filesScannedWithCache;
+  }
+
   private void runLockedByRepository(String repositoryKey, Runnable runnable) {
     var repositoryLock = repositoryLocks.computeIfAbsent(repositoryKey, k -> new ReentrantLock());
     try {
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/PythonSensor.java b/python-commons/src/main/java/org/sonar/plugins/python/PythonSensor.java
index c1daf53f76..c9775936c3 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/PythonSensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/PythonSensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -23,6 +23,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.sonar.api.SonarProduct;
@@ -35,10 +36,8 @@
 import org.sonar.api.batch.sensor.SensorDescriptor;
 import org.sonar.api.issue.NoSonarFilter;
 import org.sonar.api.measures.FileLinesContextFactory;
-import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonCustomRuleRepositoryWrapper;
 import org.sonar.plugins.python.api.PythonFileConsumer;
-import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.plugins.python.api.SonarLintCache;
 import org.sonar.plugins.python.api.SonarLintCacheWrapper;
 import org.sonar.plugins.python.api.caching.CacheContext;
@@ -51,6 +50,7 @@
 import org.sonar.plugins.python.indexer.PythonIndexer;
 import org.sonar.plugins.python.indexer.PythonIndexerWrapper;
 import org.sonar.plugins.python.indexer.SonarQubePythonIndexer;
+import org.sonar.plugins.python.telemetry.collectors.ImportsTelemetry;
 import org.sonar.plugins.python.nosonar.NoSonarLineInfoCollector;
 import org.sonar.plugins.python.telemetry.SensorTelemetryStorage;
 import org.sonar.plugins.python.telemetry.TelemetryMetricKey;
@@ -60,7 +60,6 @@
 import org.sonar.python.caching.CacheContextImpl;
 import org.sonar.python.parser.PythonParser;
 import org.sonar.python.project.config.ProjectConfigurationBuilder;
-import org.sonar.python.types.TypeShed;
 import org.sonarsource.performance.measure.PerformanceMeasure;
 
 import static org.sonar.plugins.python.Scanner.PARALLEL_PROPERTY_NAME;
@@ -85,7 +84,7 @@ public final class PythonSensor implements Sensor {
   private static final Logger LOG = LoggerFactory.getLogger(PythonSensor.class);
   static final String UNSET_VERSION_WARNING = """
     Your code is analyzed as compatible with all Python 3 versions by default. \
-    You can get a more precise analysis by setting the exact Python version in your configuration via the parameter "sonar.python.version"\
+    You can get a more precise analysis by setting the Python version or version range in your configuration via the parameter "sonar.python.version"\
     """;
 
   private final SensorTelemetryStorage sensorTelemetryStorage;
@@ -144,16 +143,12 @@ public void execute(SensorContext context) {
       LOG.warn(UNSET_VERSION_WARNING);
       analysisWarnings.addUnique(UNSET_VERSION_WARNING);
     }
-    if (pythonVersionParameter.length != 0) {
-      ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.fromStringArray(pythonVersionParameter));
-    }
     updatePythonVersionTelemetry(context, pythonVersionParameter);
     CacheContext cacheContext = CacheContextImpl.of(context);
     PythonIndexer pythonIndexer = this.indexer != null ? this.indexer : new SonarQubePythonIndexer(pythonFiles, cacheContext, context, projectConfigurationBuilder);
     pythonIndexer.setSonarLintCache(sonarLintCache);
-    TypeShed.setProjectLevelSymbolTable(pythonIndexer.projectLevelSymbolTable());
     PythonScanner scanner = new PythonScanner(context, checks, fileLinesContextFactory, noSonarFilter, PythonParser::create,
-      pythonIndexer, architectureCallback, noSonarLineInfoCollector);
+      pythonIndexer, architectureCallback, noSonarLineInfoCollector, analysisWarnings);
     scanner.execute(pythonFiles, context);
     Duration sensorTime = Duration.between(sensorStartTime, Instant.now());
 
@@ -161,6 +156,8 @@ public void execute(SensorContext context) {
     updateDatabricksTelemetry(scanner);
     updateTypeInferenceTelemetry(scanner);
     updateTestFileTelemetry(scanner);
+    updateImportsTelemetry(scanner);
+    updateCacheAnalysisTelemetry(context, pythonIndexer, scanner);
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.NOSONAR_RULE_ID_KEY, noSonarLineInfoCollector.getSuppressedRuleIds());
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.NOSONAR_COMMENTS_KEY, noSonarLineInfoCollector.getCommentWithExactlyOneRuleSuppressed());
     updateNamespacePackageTelemetry(pythonIndexer);
@@ -218,6 +215,16 @@ private void updateTestFileTelemetry(PythonScanner scanner) {
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_MAIN_LINES_MISCLASSIFIED_IMPORT_BASED_ONLY, telemetry.linesInImportBasedOnly());
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_MAIN_FILES_MISCLASSIFIED_PATH_BASED_ONLY, telemetry.filesInPathBasedOnly());
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_MAIN_LINES_MISCLASSIFIED_PATH_BASED_ONLY, telemetry.linesInPathBasedOnly());
+    sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_TEST_FILE_HEURISTIC_TRIGGERED, scanner.wasTestFileHeuristicTriggered());
+  }
+
+  private void updateImportsTelemetry(PythonScanner scanner) {
+    ImportsTelemetry telemetry = scanner.getImportsTelemetry();
+    String importsString = telemetry.importedModules().stream()
+      .sorted()
+      .collect(Collectors.joining(","));
+    sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_IMPORTS, importsString);
+    sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_IMPORTS_FORMAT_VERSION, "1");
   }
 
   private void updateNamespacePackageTelemetry(PythonIndexer pythonIndexer) {
@@ -234,25 +241,27 @@ private void updateNamespacePackageTelemetry(PythonIndexer pythonIndexer) {
   }
 
   private void updateResolutionMethodTelemetry(NamespacePackageTelemetry telemetry) {
-    PackageResolutionResult.ResolutionMethod method = telemetry.resolutionMethod();
+    PackageResolutionResult.PrimaryResolutionMethod method = telemetry.resolutionMethod();
     if (method == null) {
       return;
     }
 
     // Report boolean flags for each resolution method
-    boolean usedPyproject = method == PackageResolutionResult.ResolutionMethod.PYPROJECT_TOML
-      || method == PackageResolutionResult.ResolutionMethod.PYPROJECT_AND_SETUP_PY;
-    boolean usedSetupPy = method == PackageResolutionResult.ResolutionMethod.SETUP_PY
-      || method == PackageResolutionResult.ResolutionMethod.PYPROJECT_AND_SETUP_PY;
-    boolean usedSonarSources = method == PackageResolutionResult.ResolutionMethod.SONAR_SOURCES;
-    boolean usedConventionalFolders = method == PackageResolutionResult.ResolutionMethod.CONVENTIONAL_FOLDERS;
-    boolean usedBaseDir = method == PackageResolutionResult.ResolutionMethod.BASE_DIR;
+    boolean usedPyproject = method == PackageResolutionResult.PrimaryResolutionMethod.PYPROJECT_TOML
+      || method == PackageResolutionResult.PrimaryResolutionMethod.PYPROJECT_AND_SETUP_PY;
+    boolean usedSetupPy = method == PackageResolutionResult.PrimaryResolutionMethod.SETUP_PY
+      || method == PackageResolutionResult.PrimaryResolutionMethod.PYPROJECT_AND_SETUP_PY;
+    boolean usedSonarSources = method == PackageResolutionResult.PrimaryResolutionMethod.SONAR_SOURCES;
+    boolean usedConventionalFolders = method == PackageResolutionResult.PrimaryResolutionMethod.CONVENTIONAL_FOLDERS;
+    boolean usedBaseDir = method == PackageResolutionResult.PrimaryResolutionMethod.BASE_DIR;
+    boolean usedLegacyInitPy = method == PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY;
 
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_PYPROJECT_TOML, usedPyproject ? 1 : 0);
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SETUP_PY, usedSetupPy ? 1 : 0);
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SONAR_SOURCES, usedSonarSources ? 1 : 0);
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_CONVENTIONAL_FOLDERS, usedConventionalFolders ? 1 : 0);
     sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_BASE_DIR, usedBaseDir ? 1 : 0);
+    sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_LEGACY_INIT_PY, usedLegacyInitPy ? 1 : 0);
   }
 
   private void updateBuildSystemTelemetry(NamespacePackageTelemetry telemetry) {
@@ -276,6 +285,14 @@ private void updateBuildSystemTelemetry(NamespacePackageTelemetry telemetry) {
       buildSystem == PackageResolutionResult.BuildSystem.FLIT ? 1 : 0);
   }
 
+  private void updateCacheAnalysisTelemetry(SensorContext context, PythonIndexer indexer, PythonScanner scanner) {
+    if (context.runtime().getProduct() == SonarProduct.SONARLINT) {
+      return;
+    }
+    sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_ANALYSIS_USES_CACHE, indexer.isAnalysisOptimized());
+    sensorTelemetryStorage.updateMetric(TelemetryMetricKey.PYTHON_FILES_SCANNED_WITH_CACHE, scanner.getFilesScannedWithCache());
+  }
+
   private void updateSonarTestsTelemetry(SensorContext context) {
     if (context.runtime().getProduct() == SonarProduct.SONARLINT) {
       return;
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/Scanner.java b/python-commons/src/main/java/org/sonar/plugins/python/Scanner.java
index 046a7685b4..9b1c95f7dc 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/Scanner.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/Scanner.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/TestSourceConfiguration.java b/python-commons/src/main/java/org/sonar/plugins/python/TestSourceConfiguration.java
new file mode 100644
index 0000000000..6cdf3a354b
--- /dev/null
+++ b/python-commons/src/main/java/org/sonar/plugins/python/TestSourceConfiguration.java
@@ -0,0 +1,46 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python;
+
+import org.sonar.api.config.Configuration;
+
+import static org.sonarsource.analyzer.commons.appsec.TestFileClassifier.HEURISTIC_DISABLED_KEY;
+
+/**
+ * Resolves whether explicit test-source classification is authoritative for the analysis,
+ * in which case the test-content heuristic must not be applied.
+ */
+public final class TestSourceConfiguration {
+
+  private TestSourceConfiguration() {
+  }
+
+  /**
+   * Checks whether test source classification is explicitly configured.
+   * @param config analysis configuration
+   * @return whether the heuristic must be disabled
+   */
+  public static boolean isConfigured(Configuration config) {
+    return isPropertyConfigured(config, "sonar.tests")
+      || config.getBoolean("sonar.python.testFileHeuristic.disabled").orElse(false)
+      || config.getBoolean(HEURISTIC_DISABLED_KEY).orElse(false);
+  }
+
+  private static boolean isPropertyConfigured(Configuration config, String key) {
+    return config.get(key).filter(value -> !value.isBlank()).isPresent();
+  }
+}
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/TextReportReader.java b/python-commons/src/main/java/org/sonar/plugins/python/TextReportReader.java
index bd2e96210a..417942fc3f 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/TextReportReader.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/TextReportReader.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/architecture/ArchitectureCallbackWrapper.java b/python-commons/src/main/java/org/sonar/plugins/python/architecture/ArchitectureCallbackWrapper.java
index bf2bbca7f8..c40573d063 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/architecture/ArchitectureCallbackWrapper.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/architecture/ArchitectureCallbackWrapper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/architecture/DummyArchitectureCallback.java b/python-commons/src/main/java/org/sonar/plugins/python/architecture/DummyArchitectureCallback.java
index b4b8c48cfd..ce137c4f73 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/architecture/DummyArchitectureCallback.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/architecture/DummyArchitectureCallback.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/architecture/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/architecture/package-info.java
index d45875aa02..a9c6f617b3 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/architecture/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/architecture/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditJsonReportReader.java b/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditJsonReportReader.java
index 41ae42fa73..fbbd8add00 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditJsonReportReader.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditJsonReportReader.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditRulesDefinition.java b/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditRulesDefinition.java
index 8995858d61..ec48d1039a 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditRulesDefinition.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditRulesDefinition.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditSensor.java b/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditSensor.java
index 6af9f32a9e..d5b55f668f 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditSensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/bandit/BanditSensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/bandit/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/bandit/package-info.java
index 20cfe934e2..407d708be7 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/bandit/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/bandit/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/caching/Caching.java b/python-commons/src/main/java/org/sonar/plugins/python/caching/Caching.java
index 1e54195205..0fe0614365 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/caching/Caching.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/caching/Caching.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -24,6 +24,7 @@
 import java.util.List;
 import java.util.Set;
 import javax.annotation.CheckForNull;
+import org.sonar.api.batch.fs.InputFile;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.sonar.plugins.python.api.caching.CacheContext;
@@ -45,6 +46,8 @@ public class Caching {
   public static final String CACHE_VERSION_KEY = "python:cache_version";
   public static final String CPD_TOKENS_CACHE_KEY_PREFIX = "python:cpd:data:";
   public static final String CPD_TOKENS_STRING_TABLE_KEY_PREFIX = "python:cpd:stringTable:";
+  public static final String EFFECTIVE_FILE_TYPE_CACHE_KEY_PREFIX = "python:effective_file_type:";
+  public static final String TEST_SOURCES_CONFIGURED_KEY = "python:test_sources_configured";
 
   private static final Logger LOG = LoggerFactory.getLogger(Caching.class);
 
@@ -91,6 +94,39 @@ public void copyFromPrevious(String fileKey) {
     cacheContext.getWriteCache().copyFromPrevious(fileContentHashCacheKey(fileKey));
   }
 
+  public void writeEffectiveFileType(String fileKey, InputFile.Type type) {
+    cacheContext.getWriteCache().write(effectiveFileTypeCacheKey(fileKey), type.name().getBytes(StandardCharsets.UTF_8));
+  }
+
+  @CheckForNull
+  public InputFile.Type readEffectiveFileType(String fileKey) {
+    byte[] bytes = cacheContext.getReadCache().readBytes(effectiveFileTypeCacheKey(fileKey));
+    if (bytes != null) {
+      try {
+        return InputFile.Type.valueOf(new String(bytes, StandardCharsets.UTF_8));
+      } catch (IllegalArgumentException e) {
+        LOG.debug("Failed to deserialize cached effective file type for key: \"{}\"", fileKey);
+      }
+    }
+    return null;
+  }
+
+  public void writeTestSourcesConfigured(boolean testSourcesConfigured) {
+    cacheContext.getWriteCache().write(TEST_SOURCES_CONFIGURED_KEY, String.valueOf(testSourcesConfigured).getBytes(StandardCharsets.UTF_8));
+  }
+
+  public boolean isTestSourcesConfiguredUnchanged(boolean current) {
+    byte[] bytes = cacheContext.getReadCache().readBytes(TEST_SOURCES_CONFIGURED_KEY);
+    if (bytes == null) {
+      return false;
+    }
+    String cached = new String(bytes, StandardCharsets.UTF_8);
+    if (!"true".equals(cached) && !"false".equals(cached)) {
+      return false;
+    }
+    return current == Boolean.parseBoolean(cached);
+  }
+
   @CheckForNull
   public Set readProjectLevelSymbolTableEntry(String fileKey) {
     String key = projectSymbolTableCacheKey(fileKey);
@@ -172,4 +208,8 @@ public static String projectSymbolTableCacheKey(String key) {
   public static  String fileContentHashCacheKey(String key) {
     return CONTENT_HASHES_KEY + key.replace('\\', '/');
   }
+
+  public static String effectiveFileTypeCacheKey(String key) {
+    return EFFECTIVE_FILE_TYPE_CACHE_KEY_PREFIX + key.replace('\\', '/');
+  }
 }
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/caching/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/caching/package-info.java
index 94e995d8b6..dbbb5b11b6 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/caching/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/caching/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/coverage/CoberturaParser.java b/python-commons/src/main/java/org/sonar/plugins/python/coverage/CoberturaParser.java
index 384a8e1ee4..ed1fa5fc50 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/coverage/CoberturaParser.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/coverage/CoberturaParser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -80,7 +80,8 @@ private List extractBaseDirectories(SMInputCursor sources, File defaultBas
     while (source.getNext() != null) {
       String path = FilenameUtils.normalize(source.collectDescendantText());
       if (!StringUtils.isBlank(path)) {
-        File baseDirectory = new File(path);
+        File sourcePath = new File(path);
+        File baseDirectory = sourcePath.isAbsolute() ? sourcePath : new File(defaultBaseDirectory, path);
         if (baseDirectory.isDirectory()) {
           baseDirectories.add(baseDirectory);
         } else {
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/coverage/PythonCoverageSensor.java b/python-commons/src/main/java/org/sonar/plugins/python/coverage/PythonCoverageSensor.java
index 353959383d..89ecdbc852 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/coverage/PythonCoverageSensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/coverage/PythonCoverageSensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/coverage/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/coverage/package-info.java
index 9c3dab0975..c653fefb35 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/coverage/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/coverage/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/cpd/PythonCpdAnalyzer.java b/python-commons/src/main/java/org/sonar/plugins/python/cpd/PythonCpdAnalyzer.java
index e7f15511fc..2b7bf17292 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/cpd/PythonCpdAnalyzer.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/cpd/PythonCpdAnalyzer.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/cpd/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/cpd/package-info.java
index afaadd7b49..c8e1eead60 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/cpd/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/cpd/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/dependency/DependencyPostProcessor.java b/python-commons/src/main/java/org/sonar/plugins/python/dependency/DependencyPostProcessor.java
index beaadd4d5a..ad90ec5aad 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/dependency/DependencyPostProcessor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/dependency/DependencyPostProcessor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/dependency/DependencyTelemetry.java b/python-commons/src/main/java/org/sonar/plugins/python/dependency/DependencyTelemetry.java
index d78009ef4e..fb3b2932f4 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/dependency/DependencyTelemetry.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/dependency/DependencyTelemetry.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/dependency/PyProjectTomlParser.java b/python-commons/src/main/java/org/sonar/plugins/python/dependency/PyProjectTomlParser.java
index baa9ceae49..43d0364705 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/dependency/PyProjectTomlParser.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/dependency/PyProjectTomlParser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/dependency/RequirementsTxtParser.java b/python-commons/src/main/java/org/sonar/plugins/python/dependency/RequirementsTxtParser.java
index f258ca5990..e56584d68f 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/dependency/RequirementsTxtParser.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/dependency/RequirementsTxtParser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,8 +18,9 @@
 
 import java.io.IOException;
 import java.util.HashSet;
-import java.util.Locale;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.sonar.api.batch.fs.InputFile;
@@ -30,6 +31,12 @@ public class RequirementsTxtParser {
 
   private static final Logger LOG = LoggerFactory.getLogger(RequirementsTxtParser.class);
 
+  // Matches a PEP 508 package name, stopping before extras ("[...]") or version specifiers/markers glued without a space
+  private static final Pattern PACKAGE_NAME_PATTERN =
+    Pattern.compile("^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?(?=$|[\\[<>=!~;@])");
+
+  private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\s+");
+
   private RequirementsTxtParser(){}
 
   public static Dependencies parseRequirementFile(InputFile requirementFile) {
@@ -46,9 +53,12 @@ public static Dependencies parseRequirementFile(InputFile requirementFile) {
       if (line.isEmpty() || line.startsWith("#") || line.startsWith("-")) {
         continue;
       }
-      String[] splittedLine = line.split("\\s+");
-      if (splittedLine.length >= 1 && splittedLine[0].toUpperCase(Locale.ENGLISH).matches("^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$")) {
-        dependencySet.add(new Dependency(splittedLine[0]));
+      String[] splittedLine = WHITESPACE_PATTERN.split(line, 2);
+      if (splittedLine.length >= 1) {
+        Matcher matcher = PACKAGE_NAME_PATTERN.matcher(splittedLine[0]);
+        if (matcher.find()) {
+          dependencySet.add(new Dependency(matcher.group()));
+        }
       }
     }
     return new Dependencies(dependencySet);
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/Dependencies.java b/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/Dependencies.java
index 91f673413a..f548af4863 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/Dependencies.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/Dependencies.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/Dependency.java b/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/Dependency.java
index 4424ae798c..5405142868 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/Dependency.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/Dependency.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/package-info.java
index 8b493658b6..d888e1f0de 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/dependency/model/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/dependency/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/dependency/package-info.java
index 7723dac9b1..6e5de142e4 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/dependency/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/dependency/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/editions/OpenSourceRepositoryInfoProvider.java b/python-commons/src/main/java/org/sonar/plugins/python/editions/OpenSourceRepositoryInfoProvider.java
index a76b11b584..370bf249c0 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/editions/OpenSourceRepositoryInfoProvider.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/editions/OpenSourceRepositoryInfoProvider.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -41,4 +41,24 @@ public RepositoryInfo getIPynbInfo() {
       IPynbRuleRepository.DISABLED_RULES
     );
   }
+
+  @Override
+  public RepositoryInfo getAIProfileInfo() {
+    return new RepositoryInfo(
+      PythonRuleRepository.REPOSITORY_KEY,
+      OpenSourceCheckList.AI_QUALITY_PROFILE_LOCATION,
+      new OpenSourceCheckList().getChecks().toList(),
+      Set.of()
+    );
+  }
+
+  @Override
+  public RepositoryInfo getIPynbAIProfileInfo() {
+    return new RepositoryInfo(
+      IPynbRuleRepository.IPYTHON_REPOSITORY_KEY,
+      OpenSourceCheckList.AI_QUALITY_PROFILE_LOCATION,
+      new OpenSourceCheckList().getChecks().toList(),
+      IPynbRuleRepository.DISABLED_RULES
+    );
+  }
 }
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/editions/RepositoryInfoProvider.java b/python-commons/src/main/java/org/sonar/plugins/python/editions/RepositoryInfoProvider.java
index 378de853fe..52fe2447aa 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/editions/RepositoryInfoProvider.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/editions/RepositoryInfoProvider.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -30,6 +30,8 @@
 public interface RepositoryInfoProvider {
   RepositoryInfo getInfo();
   RepositoryInfo getIPynbInfo();
+  RepositoryInfo getAIProfileInfo();
+  RepositoryInfo getIPynbAIProfileInfo();
 
   record RepositoryInfo(String repositoryKey, String profileLocation, List> checks, Set disabledRules) {
   }
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/editions/RepositoryInfoProviderWrapper.java b/python-commons/src/main/java/org/sonar/plugins/python/editions/RepositoryInfoProviderWrapper.java
index 63cbe81cec..e1a7d3a140 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/editions/RepositoryInfoProviderWrapper.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/editions/RepositoryInfoProviderWrapper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/editions/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/editions/package-info.java
index 06a6af84b5..5fefc19c9d 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/editions/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/editions/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/flake8/Flake8RulesDefinition.java b/python-commons/src/main/java/org/sonar/plugins/python/flake8/Flake8RulesDefinition.java
index 791397bf17..676734cd1f 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/flake8/Flake8RulesDefinition.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/flake8/Flake8RulesDefinition.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/flake8/Flake8Sensor.java b/python-commons/src/main/java/org/sonar/plugins/python/flake8/Flake8Sensor.java
index 70f8d1701a..686eb4270e 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/flake8/Flake8Sensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/flake8/Flake8Sensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/flake8/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/flake8/package-info.java
index 4a0fc70b6e..8e569da162 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/flake8/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/flake8/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/ConfigSourceRoots.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/ConfigSourceRoots.java
index 6abcf35219..9a30f03929 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/ConfigSourceRoots.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/ConfigSourceRoots.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/NamespacePackageAnalyzer.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/NamespacePackageAnalyzer.java
index ab8832a855..c0cca3e010 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/NamespacePackageAnalyzer.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/NamespacePackageAnalyzer.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/NamespacePackageTelemetry.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/NamespacePackageTelemetry.java
index ecf07c12a6..74dfc58cd6 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/NamespacePackageTelemetry.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/NamespacePackageTelemetry.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -33,7 +33,7 @@ public record NamespacePackageTelemetry(
   int packagesWithoutInit,
   int duplicatePackagesWithoutInit,
   int namespacePackagesInRegularPackage,
-  @Nullable PackageResolutionResult.ResolutionMethod resolutionMethod,
+  @Nullable PackageResolutionResult.PrimaryResolutionMethod resolutionMethod,
   @Nullable PackageResolutionResult.BuildSystem buildSystem) {
   
   public static NamespacePackageTelemetry empty() {
@@ -44,7 +44,7 @@ public static NamespacePackageTelemetry empty() {
    * Creates a new telemetry instance with resolution information added.
    */
   public NamespacePackageTelemetry withResolutionInfo(
-      PackageResolutionResult.ResolutionMethod method,
+      PackageResolutionResult.PrimaryResolutionMethod method,
       PackageResolutionResult.BuildSystem system) {
     return new NamespacePackageTelemetry(
       packagesWithInit,
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PackageResolutionResult.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PackageResolutionResult.java
index b721395a55..4a5b2ddcdd 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PackageResolutionResult.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PackageResolutionResult.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -28,13 +28,13 @@
  */
 public record PackageResolutionResult(
   List roots,
-  ResolutionMethod method,
+  PrimaryResolutionMethod method,
   BuildSystem buildSystem) {
 
   /**
    * How the package roots were resolved.
    */
-  public enum ResolutionMethod {
+  public enum PrimaryResolutionMethod {
     /** Resolved from pyproject.toml build configuration */
     PYPROJECT_TOML,
     /** Resolved from setup.py configuration */
@@ -46,7 +46,9 @@ public enum ResolutionMethod {
     /** Resolved from conventional folders (src/, lib/) */
     CONVENTIONAL_FOLDERS,
     /** Fallback to project base directory */
-    BASE_DIR
+    BASE_DIR,
+    /** No build config files found; roots are computed by scanning __init__.py chains in source files */
+    LEGACY_INIT_PY
   }
 
   /**
@@ -67,26 +69,30 @@ public enum BuildSystem {
   }
 
   public static PackageResolutionResult fromPyProjectToml(List roots, BuildSystem buildSystem) {
-    return new PackageResolutionResult(roots, ResolutionMethod.PYPROJECT_TOML, buildSystem);
+    return new PackageResolutionResult(roots, PrimaryResolutionMethod.PYPROJECT_TOML, buildSystem);
   }
 
   public static PackageResolutionResult fromSetupPy(List roots) {
-    return new PackageResolutionResult(roots, ResolutionMethod.SETUP_PY, BuildSystem.NONE);
+    return new PackageResolutionResult(roots, PrimaryResolutionMethod.SETUP_PY, BuildSystem.NONE);
   }
 
   public static PackageResolutionResult fromBothPyProjectAndSetupPy(List roots, BuildSystem buildSystem) {
-    return new PackageResolutionResult(roots, ResolutionMethod.PYPROJECT_AND_SETUP_PY, buildSystem);
+    return new PackageResolutionResult(roots, PrimaryResolutionMethod.PYPROJECT_AND_SETUP_PY, buildSystem);
   }
 
   public static PackageResolutionResult fromSonarSources(List roots) {
-    return new PackageResolutionResult(roots, ResolutionMethod.SONAR_SOURCES, BuildSystem.NONE);
+    return new PackageResolutionResult(roots, PrimaryResolutionMethod.SONAR_SOURCES, BuildSystem.NONE);
   }
 
   public static PackageResolutionResult fromConventionalFolders(List roots) {
-    return new PackageResolutionResult(roots, ResolutionMethod.CONVENTIONAL_FOLDERS, BuildSystem.NONE);
+    return new PackageResolutionResult(roots, PrimaryResolutionMethod.CONVENTIONAL_FOLDERS, BuildSystem.NONE);
   }
 
   public static PackageResolutionResult fromBaseDir(List roots) {
-    return new PackageResolutionResult(roots, ResolutionMethod.BASE_DIR, BuildSystem.NONE);
+    return new PackageResolutionResult(roots, PrimaryResolutionMethod.BASE_DIR, BuildSystem.NONE);
+  }
+
+  public static PackageResolutionResult fromLegacyInitPy(List roots) {
+    return new PackageResolutionResult(roots, PrimaryResolutionMethod.LEGACY_INIT_PY, BuildSystem.NONE);
   }
 }
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PackageRootResolver.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PackageRootResolver.java
index 93cdb45c0a..a61174501a 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PackageRootResolver.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PackageRootResolver.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,19 +16,45 @@
  */
 package org.sonar.plugins.python.indexer;
 
+import static org.sonar.python.semantic.SymbolUtils.resolvedPath;
+
+import com.google.common.annotations.VisibleForTesting;
 import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
+import java.util.function.BiFunction;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.sonar.api.batch.fs.FileSystem;
+import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.config.Configuration;
 
 /**
  * Resolves package root directories for Python projects.
  *
- * 
                This class validates and resolves package roots extracted from build system configurations
- * (e.g., pyproject.toml) and provides fallback resolution when no roots are configured.
+ * 
                This class is the single source of truth for package root resolution. It handles:
+ * 
                  
+ *   
                • Extraction from pyproject.toml build system configurations
                  • 
+ *   
                • Extraction from setup.py configurations
                  • 
+ *   
                • When no build config files exist: computes roots by scanning Python source files
+ *       and walking up __init__.py chains to find the first parent directory without __init__.py
+ *       for each file (legacy detection mode)
                  • 
+ *   
                • Fallback when build files exist but provide no roots: conventional folders (src/, lib/),
+ *       then sonar.sources, then base directory
                  • 
+ * 
                
  */
 public class PackageRootResolver {
+
+  private static final Logger LOG = LoggerFactory.getLogger(PackageRootResolver.class);
+
   static final String SONAR_SOURCES_KEY = "sonar.sources";
   static final List CONVENTIONAL_FOLDERS = List.of("src", "lib");
 
@@ -36,59 +62,146 @@ private PackageRootResolver() {
   }
 
   /**
-   * Resolves package root directories.
+   * Resolves package root directories for the project.
    *
-   * 
                If extracted roots from build system configuration are provided (already as absolute paths
-   * resolved relative to their config file locations), returns them directly.
-   * Otherwise, applies a fallback chain to determine appropriate roots.
+   * 
                Attempts to extract source roots from pyproject.toml and setup.py build system configurations.
+   * When no build config files exist, computes roots by scanning the provided Python source files
+   * and walking up __init__.py chains to find the package root for each file. When build config
+   * files exist but provide no source roots, conventional folders take priority over sonar.sources,
+   * then base directory as last resort.
    *
-   * @param extractedRoots roots extracted from build system config, already as absolute paths
-   * @param config the Sonar configuration to read sonar.sources property
-   * @param baseDir the project base directory (used only for fallback resolution)
-   * @return list of resolved package root absolute paths
+   * @param fileSystem the Sonar file system providing the base directory
+   * @param config the Sonar configuration
+   * @param pythonFiles the Python source files in the project (used for legacy root computation)
+   * @return resolution result including resolved root absolute paths and method information
    */
-  public static List resolve(List extractedRoots, Configuration config, File baseDir) {
-    if (!extractedRoots.isEmpty()) {
-      // Extracted roots are already absolute paths (resolved relative to config file location)
-      return extractedRoots;
+  public static PackageResolutionResult resolve(FileSystem fileSystem, Configuration config, Iterable pythonFiles) {
+    File baseDir = fileSystem.baseDir();
+
+    // Discover build config files
+    BuildConfigFiles buildConfigFiles = findBuildConfigFiles(fileSystem);
+    List pyprojectFiles = buildConfigFiles.pyprojectFiles();
+    List setupPyFiles = buildConfigFiles.setupPyFiles();
+    boolean hasBuildConfigFiles = !pyprojectFiles.isEmpty() || !setupPyFiles.isEmpty();
+
+    // When no build config files exist, compute roots from __init__.py chains in source files.
+    if (!hasBuildConfigFiles) {
+      List legacyRoots = computeLegacyRoots(pythonFiles, baseDir);
+      LOG.debug("No build config files found; computed package roots from __init__.py detection: {}", legacyRoots);
+      return PackageResolutionResult.fromLegacyInitPy(legacyRoots);
+    }
+
+    // Extract source roots from discovered files
+    List pyprojectResults = pyprojectFiles.stream()
+      .map(PyProjectTomlSourceRoots::extractWithBuildSystem)
+      .filter(PyProjectExtractionResult::hasRoots)
+      .toList();
+    List setupPyRoots = setupPyFiles.stream()
+      .map(SetupPySourceRoots::extractWithLocation)
+      .filter(csr -> !csr.relativeRoots().isEmpty())
+      .toList();
+
+    boolean hasPyprojectRoots = pyprojectResults.stream().anyMatch(PyProjectExtractionResult::hasRoots);
+    boolean hasSetupPyRoots = !setupPyRoots.isEmpty();
+
+    List combinedRoots = Stream.concat(
+        pyprojectResults.stream().map(PyProjectExtractionResult::configRoots).flatMap(crs -> crs.toAbsolutePaths().stream()),
+        setupPyRoots.stream().flatMap(csr -> csr.toAbsolutePaths().stream()))
+      .distinct()
+      .toList();
+
+    // Build configs exist but extracted no roots — fall back, then augment with uncovered files.
+    if (!hasPyprojectRoots && !hasSetupPyRoots) {
+      return resolveRootsWhenBuildConfigHasNoSourceRoots(config, baseDir, pythonFiles);
+    }
+
+    List adjustedRoots = augmentWithUncoveredFileRoots(adjustRoots(combinedRoots, baseDir), pythonFiles, baseDir);
+    LOG.debug("Resolved package roots from build configuration: {}", adjustedRoots);
+
+    if (hasPyprojectRoots && hasSetupPyRoots) {
+      return PackageResolutionResult.fromBothPyProjectAndSetupPy(adjustedRoots, getCombinedBuildSystem(pyprojectResults));
+    }
+
+    if (hasPyprojectRoots) {
+      return PackageResolutionResult.fromPyProjectToml(adjustedRoots, getCombinedBuildSystem(pyprojectResults));
     }
-    return resolveFallback(config, baseDir);
+
+    return PackageResolutionResult.fromSetupPy(adjustedRoots);
   }
 
   /**
-   * Resolves fallback package roots when no build system configuration is available.
-   *
-   * 
                Fallback priority:
-   * 
                  
-   *   
                1. sonar.sources property if set
                  2. 
-   *   
                2. "src" and/or "lib" folders if they exist
                  3. 
-   *   
                3. Project base directory absolute path as last resort
                  4. 
-   * 
                
+   * Resolves fallback package roots when build config files exist but provide no source roots.
    *
-   * @param config  the Sonar configuration
-   * @param baseDir the project base directory
-   * @return list of fallback package root absolute paths
+   * 
                Priority order: conventional folders (src/, lib/), then sonar.sources, then base directory.
+   * After resolving the primary roots, augments with legacy __init__.py-based roots for any
+   * Python files not covered by the resolved roots.
    */
-  static List resolveFallback(Configuration config, File baseDir) {
-    String[] sonarSources = config.getStringArray(SONAR_SOURCES_KEY);
-    if (sonarSources.length > 0) {
-      return toAbsolutePaths(Arrays.asList(sonarSources), baseDir);
+  private static PackageResolutionResult resolveRootsWhenBuildConfigHasNoSourceRoots(Configuration config, File baseDir, Iterable pythonFiles) {
+    List>> candidates =
+      List.of(PackageRootResolver::tryConventionalFolders, PackageRootResolver::trySonarSources);
+    for (BiFunction> candidate : candidates) {
+      Optional result = candidate.apply(config, baseDir);
+      if (result.isPresent()) {
+        var augmentedRoots = augmentWithUncoveredFileRoots(result.get().roots(), pythonFiles, baseDir);
+        return new PackageResolutionResult(augmentedRoots, result.get().method(), result.get().buildSystem());
+      }
     }
 
+    LOG.debug("Using project base directory as package root (fallback)");
+    return PackageResolutionResult.fromBaseDir(List.of(baseDir.getAbsolutePath()));
+  }
+
+  private static Optional tryConventionalFolders(Configuration config, File baseDir) {
     List conventionalFolders = findConventionalFolders(baseDir);
-    if (!conventionalFolders.isEmpty()) {
-      return toAbsolutePaths(conventionalFolders, baseDir);
+    if (conventionalFolders.isEmpty()) {
+      return Optional.empty();
     }
+    List adjustedRoots = adjustRoots(toAbsolutePaths(conventionalFolders, baseDir), baseDir);
+    LOG.debug("Resolved package roots from fallback (conventional folders): {}", adjustedRoots);
+    return Optional.of(PackageResolutionResult.fromConventionalFolders(adjustedRoots));
+  }
 
-    return List.of(baseDir.getAbsolutePath());
+  private static Optional trySonarSources(Configuration config, File baseDir) {
+    String[] sonarSources = config.getStringArray(SONAR_SOURCES_KEY);
+    if (sonarSources.length == 0) {
+      return Optional.empty();
+    }
+    List adjustedRoots = adjustRoots(toAbsolutePaths(Arrays.asList(sonarSources), baseDir), baseDir);
+    LOG.debug("Resolved package roots from fallback (sonar.sources): {}", adjustedRoots);
+    return Optional.of(PackageResolutionResult.fromSonarSources(adjustedRoots));
   }
 
-  private static List toAbsolutePaths(List paths, File baseDir) {
+  /**
+   * Converts path strings to normalized absolute paths.
+   *
+   * 
                Relative paths are resolved against the given base directory. Windows-style absolute paths
+   * (e.g. {@code C:\path\to\src} or {@code C:/path/to/src}) are used as-is without prepending the
+   * base directory, which would otherwise produce a nonsensical path on non-Windows systems.
+   *
+   * 
                Uses {@link Path#normalize()} to resolve {@code .} and {@code ..} components without
+   * performing any I/O, so that {@code sonar.sources=.} correctly resolves to the base directory
+   * rather than producing an un-normalized path like {@code /project/.}.
+   */
+  static List toAbsolutePaths(List paths, File baseDir) {
     return paths.stream()
-      .map(path -> new File(baseDir, path).getAbsolutePath())
+      .map(path -> {
+        File file = isWindowsAbsolutePath(path) ? new File(path) : new File(baseDir, path);
+        return file.toPath().normalize().toString();
+      })
       .toList();
   }
 
+  /**
+   * Returns {@code true} if the given path is a Windows-style absolute path (e.g. {@code C:\...}
+   * or {@code C:/...}), regardless of the current operating system.
+   */
+  private static boolean isWindowsAbsolutePath(String path) {
+    return path.length() >= 3
+      && Character.isLetter(path.charAt(0))
+      && path.charAt(1) == ':'
+      && (path.charAt(2) == '\\' || path.charAt(2) == '/');
+  }
+
   private static List findConventionalFolders(File baseDir) {
     List folders = new ArrayList<>();
     for (String folderName : CONVENTIONAL_FOLDERS) {
@@ -99,5 +212,183 @@ private static List findConventionalFolders(File baseDir) {
     }
     return folders;
   }
-}
 
+  private static List adjustRoots(List roots, File baseDir) {
+    return roots.stream()
+      .map(root -> {
+        File rootAsFile = new File(root);
+        if (rootAsFile.isAbsolute()) {
+          // Native absolute path (works on any OS, including Windows running on Windows).
+          return adjustPackageRoot(rootAsFile, baseDir);
+        }
+        if (isWindowsAbsolutePath(root)) {
+          // Windows-style absolute path (e.g. C:\src) on a non-Windows system: File.isAbsolute()
+          // returns false, so we must not pass it to new File(baseDir, root) or getAbsolutePath()
+          // would prepend the JVM working directory. Return as-is; __init__.py traversal is not
+          // meaningful for a foreign-OS path.
+          return root;
+        }
+        return adjustPackageRoot(new File(baseDir, root), baseDir);
+      })
+      .distinct()
+      .toList();
+  }
+
+  /**
+   * Adjusts a package root by walking up the directory tree if it contains __init__.py.
+   *
+   * 
                If the root directory contains __init__.py, it's part of a package, not the package root.
+   * We walk up to find the first parent directory without __init__.py.
+   *
+   * @param root    the potential package root directory
+   * @param baseDir the project base directory (we don't walk above this)
+   * @return the adjusted package root absolute path
+   */
+  @VisibleForTesting
+  static String adjustPackageRoot(File root, File baseDir) {
+    File current = root;
+    String baseDirPath = baseDir.getAbsolutePath();
+    Path comparableBaseDirPath = resolvedPath(baseDir);
+    while (current != null && !resolvedPath(current).equals(comparableBaseDirPath)) {
+      File initFile = new File(current, "__init__.py");
+      if (!initFile.exists()) {
+        break;
+      }
+      current = current.getParentFile();
+    }
+    if (current == null || resolvedPath(current).equals(comparableBaseDirPath)) {
+      return baseDirPath;
+    }
+    Path comparableCurrentPath = resolvedPath(current);
+    if (comparableCurrentPath.startsWith(comparableBaseDirPath)) {
+      Path relativePath = comparableBaseDirPath.relativize(comparableCurrentPath);
+      return baseDir.toPath().toAbsolutePath().resolve(relativePath).normalize().toString();
+    }
+    return current.getAbsolutePath();
+  }
+
+  /**
+   * Computes package root directories for a set of files by walking up __init__.py chains.
+   *
+   * 
                For each file, walks up from the file's parent directory toward the base directory,
+   * stopping at the first directory that does not contain an __init__.py. That directory is the
+   * package root for that file. Roots are deduplicated and sorted by path length descending so
+   * that the most specific root is matched first.
+   *
+   * 
                If no files are provided, returns the base directory as the single root.
+   *
+   * @param files   the Python source files whose roots to compute
+   * @param baseDir the project base directory (walk-up never crosses this boundary)
+   * @return deduplicated absolute package root paths, sorted deepest-first
+   */
+  public static List computePackageRootsFromFiles(List files, File baseDir) {
+    List roots = files.stream()
+      .map(f -> adjustPackageRoot(f.getParentFile(), baseDir))
+      .distinct()
+      .sorted(deepestFirstComparator())
+      .toList();
+    return roots.isEmpty() ? List.of(baseDir.getAbsolutePath()) : roots;
+  }
+
+  /**
+   * Augments build-config roots with legacy __init__.py-based roots for files not covered
+   * by any existing root.
+   *
+   * 
                Build configuration files (setup.py, pyproject.toml) typically declare only the source
+   * package roots (e.g. {@code src/}). Files outside those roots — most commonly test files
+   * under a {@code tests/} directory that has its own {@code __init__.py} — would otherwise
+   * receive an empty package name, breaking FQN resolution and type inference.
+   *
+   * 
                This method identifies such uncovered files and computes additional roots for them
+   * using the same __init__.py walk-up algorithm used for legacy projects.
+   */
+  private static List augmentWithUncoveredFileRoots(List configRoots, Iterable pythonFiles, File baseDir) {
+    List comparableRoots = configRoots.stream()
+      .map(root -> resolvedPath(new File(root)))
+      .toList();
+    List uncoveredFiles = StreamSupport.stream(pythonFiles.spliterator(), false)
+      .map(InputFile::file)
+      .filter(file -> !isUnderAnyComparableRoot(file, comparableRoots))
+      .toList();
+
+    if (uncoveredFiles.isEmpty()) {
+      return configRoots.stream()
+        .sorted(deepestFirstComparator())
+        .toList();
+    }
+
+    List additionalRoots = computePackageRootsFromFiles(uncoveredFiles, baseDir);
+    return Stream.concat(configRoots.stream(), additionalRoots.stream())
+      .distinct()
+      .sorted(deepestFirstComparator())
+      .toList();
+  }
+
+  private static boolean isUnderAnyComparableRoot(File file, List roots) {
+    Path filePath = resolvedPath(file);
+    for (Path root : roots) {
+      if (filePath.startsWith(root)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private static List computeLegacyRoots(Iterable pythonFiles, File baseDir) {
+    List files = StreamSupport.stream(pythonFiles.spliterator(), false)
+      .map(InputFile::file)
+      .toList();
+    return computePackageRootsFromFiles(files, baseDir);
+  }
+
+  /**
+   * Recursively finds supported build configuration files under the project base directory.
+   */
+  private static BuildConfigFiles findBuildConfigFiles(FileSystem fileSystem) {
+    List pyprojectFiles = new ArrayList<>();
+    List setupPyFiles = new ArrayList<>();
+    try (Stream stream = Files.walk(fileSystem.baseDir().toPath())) {
+      stream
+        .filter(Files::isRegularFile)
+        .forEach(path -> {
+          String filename = path.getFileName().toString();
+          if ("pyproject.toml".equals(filename)) {
+            pyprojectFiles.add(path.toFile());
+          } else if ("setup.py".equals(filename)) {
+            setupPyFiles.add(path.toFile());
+          }
+        });
+    } catch (IOException e) {
+      return new BuildConfigFiles(List.of(), List.of());
+    }
+    return new BuildConfigFiles(List.copyOf(pyprojectFiles), List.copyOf(setupPyFiles));
+  }
+
+  private record BuildConfigFiles(List pyprojectFiles, List setupPyFiles) {
+  }
+
+  /**
+   * Returns a comparator that sorts package root paths deepest-first (by separator count),
+   * breaking ties alphabetically.
+   */
+  private static Comparator deepestFirstComparator() {
+    return Comparator.comparingInt(PackageRootResolver::pathDepth).reversed().thenComparing(Comparator.naturalOrder());
+  }
+
+  private static int pathDepth(String path) {
+    return (int) path.chars().filter(c -> c == File.separatorChar).count();
+  }
+
+  /**
+   * Determines the combined build system across multiple pyproject.toml results.
+   * If multiple files report different build systems, returns MULTIPLE.
+   */
+  private static PackageResolutionResult.BuildSystem getCombinedBuildSystem(List pyprojectResults) {
+    return pyprojectResults.stream()
+      .map(PyProjectExtractionResult::buildSystem)
+      .filter(bs -> bs != PackageResolutionResult.BuildSystem.NONE)
+      .distinct()
+      .reduce((a, b) -> PackageResolutionResult.BuildSystem.MULTIPLE)
+      .orElse(PackageResolutionResult.BuildSystem.NONE);
+  }
+}
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/ProjectTree.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/ProjectTree.java
index b36c18edbc..0586aceba2 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/ProjectTree.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/ProjectTree.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/ProjectTreeBuilder.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/ProjectTreeBuilder.java
index ad02682550..ea62a43bf0 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/ProjectTreeBuilder.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/ProjectTreeBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PyProjectExtractionResult.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PyProjectExtractionResult.java
index 6945f7a66c..89e8bef417 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PyProjectExtractionResult.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PyProjectExtractionResult.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PyProjectTomlSourceRoots.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PyProjectTomlSourceRoots.java
index d69298cf26..d9d398f37e 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PyProjectTomlSourceRoots.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PyProjectTomlSourceRoots.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -39,7 +39,8 @@
  * 
                Supports the following build systems:
  * 
                  
  *   
                • setuptools: {@code [tool.setuptools.packages.find] where = ["src"]}
                  • 
- *   
                • Poetry: {@code [tool.poetry] packages = [{from = "src", include = "pkg"}]}
                  • 
+ *   
                • Poetry: {@code [tool.poetry] packages = [{from = "src", include = "pkg"}]}
+ *       or auto-detects src/ layout when build-backend is poetry.core.masonry.api
                  • 
  *   
                • Hatchling: {@code [tool.hatch.build.targets.wheel] sources = ["src"]}
                  • 
  *   
                • uv_build: {@code [build-system] build-backend = "uv_build"} or {@code [tool.uv.build-backend] module-root = "src"} - auto-detects src/ layout by convention
                  • 
  *   
                • PDM: {@code [tool.pdm] package-dir = "src"}
                  • 
@@ -130,7 +131,7 @@ private static PyProjectExtractionResult extractFromConfig(PyProjectConfig confi
         detectedBuildSystems.add(PackageResolutionResult.BuildSystem.SETUPTOOLS);
       }
 
-      List poetryRoots = extractFromPoetry(configTool.poetry());
+      List poetryRoots = extractFromPoetry(configTool.poetry(), config.buildSystem());
       if (!poetryRoots.isEmpty()) {
         sourceRoots.addAll(poetryRoots);
         detectedBuildSystems.add(PackageResolutionResult.BuildSystem.POETRY);
@@ -199,6 +200,16 @@ private static List extractFromUVBuildSystem(@Nullable BuildSystem build
     return List.of();
   }
 
+  /**
+   * Checks if the build backend is Poetry (e.g., poetry.core.masonry.api).
+   */
+  private static boolean isPoetryBuildBackend(@Nullable BuildSystem buildSystem) {
+    if (buildSystem == null || buildSystem.buildBackend() == null) {
+      return false;
+    }
+    return buildSystem.buildBackend().contains("poetry");
+  }
+
   // === Setuptools ===
   // [tool.setuptools.packages.find]
   // where = ["src"]
@@ -213,16 +224,30 @@ private static List extractFromSetuptools(@Nullable Setuptools setuptool
   // === Poetry ===
   // [tool.poetry]
   // packages = [{ include = "mypackage", from = "src" }]
+  // Or auto-detects src/ layout when build-backend is poetry.core.masonry.api
+
+  private static List extractFromPoetry(@Nullable Poetry poetry, @Nullable BuildSystem buildSystem) {
+    // First try to get explicit "from" paths from packages
+    if (poetry != null) {
+      List explicitRoots = poetry.packages().stream()
+        .map(PoetryPackage::from)
+        .filter(from -> from != null && !from.isEmpty())
+        .distinct()
+        .toList();
 
-  private static List extractFromPoetry(@Nullable Poetry poetry) {
-    if (poetry == null) {
-      return List.of();
+      if (!explicitRoots.isEmpty()) {
+        return explicitRoots;
+      }
     }
-    return poetry.packages().stream()
-      .map(PoetryPackage::from)
-      .filter(from -> from != null && !from.isEmpty())
-      .distinct()
-      .toList();
+
+    // If Poetry is the build backend but no explicit paths, use src-layout default
+    // Poetry auto-detects packages in src/ or project root; we default to src/
+    // and rely on legacy fallback for flat-layout projects
+    if (isPoetryBuildBackend(buildSystem)) {
+      return List.of("src");
+    }
+
+    return List.of();
   }
 
   // === Hatchling ===
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PythonIndexer.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PythonIndexer.java
index a65e6061e0..b246dc33bf 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PythonIndexer.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PythonIndexer.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,23 +16,19 @@
  */
 package org.sonar.plugins.python.indexer;
 
-import com.google.common.annotations.VisibleForTesting;
 import com.sonar.sslr.api.AstNode;
 import java.io.File;
 import java.io.IOException;
 import java.net.URI;
-import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
-import java.util.stream.Stream;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.sonar.api.batch.fs.FileSystem;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.sensor.SensorContext;
 import org.sonar.plugins.python.PythonInputFile;
@@ -53,14 +49,15 @@
 import org.sonar.python.tree.PythonTreeMaker;
 
 import static org.sonar.python.semantic.SymbolUtils.pythonPackageName;
+import static org.sonar.python.semantic.SymbolUtils.resolvedPath;
 
 public abstract class PythonIndexer {
 
   private static final Logger LOG = LoggerFactory.getLogger(PythonIndexer.class);
 
-  protected String projectBaseDirAbsolutePath;
   protected List packageRoots = List.of();
   protected @Nullable PackageResolutionResult packageResolutionResult;
+  private List resolvedPackageRoots = List.of();
 
   private final Map packageNames = new ConcurrentHashMap<>();
   private final Supplier parserSupplier = PythonParser::create;
@@ -95,7 +92,7 @@ protected void recreateProjectLevelTypeTable() {
 
   public String packageName(PythonInputFile inputFile) {
     if (!packageNames.containsKey(inputFile.wrappedFile().uri())) {
-      String name = pythonPackageName(inputFile.wrappedFile().file(), packageRoots, projectBaseDirAbsolutePath);
+      String name = pythonPackageName(inputFile.wrappedFile().file(), resolvedPackageRoots);
       packageNames.put(inputFile.wrappedFile().uri(), name);
       projectLevelSymbolTable.addProjectPackage(name);
     }
@@ -106,210 +103,48 @@ public List packageRoots() {
     return packageRoots;
   }
 
+  protected void clearProjectIndex() {
+    packageNames.clear();
+    projectLevelSymbolTable.clear();
+    projectConfigurationBuilder.clear();
+  }
+
   /**
    * Resolves package root directories for the project.
    *
-   * 
                  Attempts to extract source roots from pyproject.toml and setup.py build system configurations.
-   * Falls back to sonar.sources property, conventional folders (src/, lib/), or the project base directory.
+   * 
                  Delegates entirely to {@link PackageRootResolver}, which is the single source of truth
+   * for package root resolution (pyproject.toml, setup.py, fallback chain).
    *
    * @param context the sensor context containing filesystem and configuration
    * @return list of resolved package root absolute paths
    */
   protected List resolvePackageRoots(SensorContext context) {
-    PackageResolutionResult result = resolvePackageRootsWithMethod(context);
-    this.packageResolutionResult = result;
-    return result.roots();
-  }
-
-  /**
-   * Resolves package root directories and tracks the resolution method used.
-   *
-   * @param context the sensor context containing filesystem and configuration
-   * @return resolution result including roots and method information
-   */
-  protected PackageResolutionResult resolvePackageRootsWithMethod(SensorContext context) {
-    FileSystem fileSystem = context.fileSystem();
-    File baseDir = fileSystem.baseDir();
-
-    // Try both pyproject.toml and setup.py
-    List pyprojectResults = extractSourceRootsFromPyProjectTomlWithBuildSystem(fileSystem);
-    List setupPyRoots = extractSourceRootsFromSetupPy(fileSystem);
-
-    boolean hasPyproject = pyprojectResults.stream().anyMatch(PyProjectExtractionResult::hasRoots);
-    boolean hasSetupPy = !setupPyRoots.isEmpty();
-    List combinedRoots = Stream.concat(
-        pyprojectResults.stream().map(PyProjectExtractionResult::configRoots).flatMap( crs -> crs.toAbsolutePaths().stream()),
-        setupPyRoots.stream().flatMap(csr -> csr.toAbsolutePaths().stream())
-      )
-      .distinct()
-      .toList();
-
-    List adjustedRoots = adjustRoots(combinedRoots, baseDir);
-    LOG.debug("Resolved package roots from build configuration: {}", adjustedRoots);
-
-    if (hasPyproject && hasSetupPy) {
-      return PackageResolutionResult.fromBothPyProjectAndSetupPy(adjustedRoots, getCombinedBuildSystem(pyprojectResults));
-    }
-
-    if (hasPyproject) {
-      return PackageResolutionResult.fromPyProjectToml(adjustedRoots, getCombinedBuildSystem(pyprojectResults));
-    }
-
-    if (hasSetupPy) {
-      return PackageResolutionResult.fromSetupPy(adjustedRoots);
-    }
-
-    // Fallback to PackageRootResolver
-    return resolveFallback(context.config(), baseDir);
-  }
-
-  /**
-   * Determine the build system (if multiple files have different build systems, use MULTIPLE)
-   * @param pyprojectResults the list of pyproject extraction results to analyze
-   * @return the combined build system result for the project
-   */
-  private static PackageResolutionResult.BuildSystem getCombinedBuildSystem(List pyprojectResults) {
-    return pyprojectResults.stream()
-      .map(PyProjectExtractionResult::buildSystem)
-      .filter(bs -> bs != PackageResolutionResult.BuildSystem.NONE)
-      .distinct()
-      .reduce((a, b) -> PackageResolutionResult.BuildSystem.MULTIPLE)
-      .orElse(PackageResolutionResult.BuildSystem.NONE);
-  }
-
-  /**
-   * Resolves fallback package roots when no build configuration is available.
-   */
-  private static PackageResolutionResult resolveFallback(org.sonar.api.config.Configuration config, File baseDir) {
-    String[] sonarSources = config.getStringArray(PackageRootResolver.SONAR_SOURCES_KEY);
-    if (sonarSources.length > 0) {
-      List roots = toAbsolutePaths(java.util.Arrays.asList(sonarSources), baseDir);
-      List adjustedRoots = adjustRoots(roots, baseDir);
-      LOG.debug("Resolved package roots from fallback (sonar.sources or conventional folders): {}", adjustedRoots);
-      return PackageResolutionResult.fromSonarSources(adjustedRoots);
-    }
-
-    List conventionalFolders = findConventionalFolders(baseDir);
-    if (!conventionalFolders.isEmpty()) {
-      List roots = toAbsolutePaths(conventionalFolders, baseDir);
-      List adjustedRoots = adjustRoots(roots, baseDir);
-      LOG.debug("Resolved package roots from fallback (sonar.sources or conventional folders): {}", adjustedRoots);
-      return PackageResolutionResult.fromConventionalFolders(adjustedRoots);
-    }
-
-    List baseDirRoots = List.of(baseDir.getAbsolutePath());
-    LOG.debug("Using project base directory as package root (fallback)");
-    return PackageResolutionResult.fromBaseDir(baseDirRoots);
-  }
-
-  private static List adjustRoots(List roots, File baseDir) {
-    return roots.stream()
-      .map(root -> {
-        File rootFile = new File(root).isAbsolute() ? new File(root) : new File(baseDir, root);
-        return adjustPackageRoot(rootFile, baseDir);
-      })
-      .distinct()
-      .toList();
+    var fs = context.fileSystem();
+    Iterable pythonFiles = fs.inputFiles(fs.predicates().hasLanguage("py"));
+    PackageResolutionResult result = PackageRootResolver.resolve(fs, context.config(), pythonFiles);
+    setPackageResolutionResult(result);
+    return packageRoots;
   }
 
-  private static List toAbsolutePaths(List paths, File baseDir) {
-    return paths.stream()
-      .map(path -> new File(baseDir, path).getAbsolutePath())
+  protected void setPackageResolutionResult(PackageResolutionResult result) {
+    this.packageRoots = result.roots();
+    this.resolvedPackageRoots = packageRoots.stream()
+      .map(root -> resolvedPath(new File(root)))
       .toList();
+    this.packageResolutionResult = result;
   }
 
-  private static List findConventionalFolders(File baseDir) {
-    List folders = new java.util.ArrayList<>();
-    for (String folderName : PackageRootResolver.CONVENTIONAL_FOLDERS) {
-      File folder = new File(baseDir, folderName);
-      if (folder.exists() && folder.isDirectory()) {
-        folders.add(folderName);
-      }
-    }
-    return folders;
-  }
-
-  /**
-   * Adjusts a package root by walking up the directory tree if it contains __init__.py.
-   *
-   * 
                  If the root directory contains __init__.py, it's part of a package, not the package root.
-   * We walk up to find the first parent directory without __init__.py.
-   *
-   * @param root the potential package root directory
-   * @param baseDir the project base directory (we don't walk above this)
-   * @return the adjusted package root absolute path
-   */
-  @VisibleForTesting
-  static String adjustPackageRoot(File root, File baseDir) {
-    File current = root;
-    String baseDirPath = baseDir.getAbsolutePath();
-    while (current != null && !current.getAbsolutePath().equals(baseDirPath)) {
-      File initFile = new File(current, "__init__.py");
-      if (!initFile.exists()) {
-        break;
-      }
-      current = current.getParentFile();
-    }
-    if (current == null) {
-      return baseDirPath;
-    }
-    return current.getAbsolutePath();
+  protected boolean isResolvedPackageRoot(Path candidateRoot) {
+    return resolvedPackageRoots.contains(candidateRoot);
   }
 
-  /**
-   * Recursively finds files with the given filename in the project directory.
-   *
-   * @param fileSystem the file system to search in
-   * @param filename the filename to search for (e.g., "pyproject.toml", "setup.py")
-   * @return stream of matching files
-   */
-  private static Stream findFilesRecursively(FileSystem fileSystem, String filename) {
-    try {
-      return Files.walk(fileSystem.baseDir().toPath())
-        .filter(Files::isRegularFile)
-        .filter(path -> filename.equals(path.getFileName().toString()))
-        .map(Path::toFile);
-    } catch (IOException e) {
-      return Stream.empty();
-    }
-  }
-
-  /**
-   * Extracts source root directories from pyproject.toml files in the project.
-   *
-   * @param fileSystem the file system to search for pyproject.toml
-   * @return extraction result with source roots and build system info
-   */
-  private static List extractSourceRootsFromPyProjectTomlWithBuildSystem(FileSystem fileSystem) {
-    List results = findFilesRecursively(fileSystem, "pyproject.toml")
-      .map(PyProjectTomlSourceRoots::extractWithBuildSystem)
-      .filter(PyProjectExtractionResult::hasRoots)
-      .toList();
-
-    if (results.isEmpty()) {
-      return List.of();
-    }
-
-    return results;
-  }
-
-  /**
-   * Extracts source root directories from setup.py files in the project.
-   *
-   * @param fileSystem the file system to search for setup.py
-   * @return list of ConfigSourceRoots containing config file locations and their relative roots
-   */
-  private static List extractSourceRootsFromSetupPy(FileSystem fileSystem) {
-    return findFilesRecursively(fileSystem, "setup.py")
-      .map(SetupPySourceRoots::extractWithLocation)
-      .filter(csr -> !csr.relativeRoots().isEmpty())
-      .toList();
+  protected boolean isUnderResolvedPackageRoot(Path path) {
+    return resolvedPackageRoots.stream().anyMatch(path::startsWith);
   }
 
   public void collectPackageNames(List inputFiles) {
     for (PythonInputFile inputFile : inputFiles) {
-      String packageName = pythonPackageName(inputFile.wrappedFile().file(), packageRoots, projectBaseDirAbsolutePath);
-      projectLevelSymbolTable.addProjectPackage(packageName);
+      packageName(inputFile);
     }
   }
 
@@ -350,9 +185,7 @@ void removeFile(PythonInputFile inputFile) {
   void addFile(PythonInputFile inputFile) throws IOException {
     AstNode astNode = parserSupplier.get().parse(inputFile.wrappedFile().contents());
     FileInput astRoot = new PythonTreeMaker().fileInput(astNode);
-    String packageName = pythonPackageName(inputFile.wrappedFile().file(), packageRoots, projectBaseDirAbsolutePath);
-    packageNames.put(inputFile.wrappedFile().uri(), packageName);
-    projectLevelSymbolTable.addProjectPackage(packageName);
+    String packageName = packageName(inputFile);
     PythonFile pythonFile = SonarQubePythonFile.create(inputFile.wrappedFile());
     projectLevelSymbolTable.addModule(astRoot, packageName, pythonFile);
     signatureBasedAwsLambdaHandlersCollector.collect(projectConfigurationBuilder, astRoot, packageName);
@@ -397,6 +230,18 @@ public boolean canBeFullyScannedWithoutParsing(PythonInputFile inputFile) {
 
   public abstract CacheContext cacheContext();
 
+  public boolean isAnalysisOptimized() {
+    return false;
+  }
+
+  public void writeEffectiveFileType(String fileKey, InputFile.Type type) {
+  }
+
+  @CheckForNull
+  public InputFile.Type readEffectiveFileType(String fileKey) {
+    return null;
+  }
+
   class GlobalSymbolsScanner extends Scanner {
     protected GlobalSymbolsScanner(SensorContext context) {
       super(context);
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PythonIndexerWrapper.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PythonIndexerWrapper.java
index 1a98b54738..5dadecdc30 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/PythonIndexerWrapper.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/PythonIndexerWrapper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/SetupPySourceRoots.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/SetupPySourceRoots.java
index 7d152fc10e..03750cc32f 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/SetupPySourceRoots.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/SetupPySourceRoots.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -149,7 +149,7 @@ public void visitCallExpression(CallExpression callExpression) {
      */
     private void extractFromUnpackingArguments(CallExpression callExpression) {
       for (Argument argument : callExpression.arguments()) {
-        if (argument instanceof UnpackingExpression unpacking && "**".equals(unpacking.starToken().value())) {
+        if (argument instanceof UnpackingExpression unpacking && TreeUtils.isDoubleStarExpression(unpacking)) {
           Expression unpackedExpr = resolveExpression(unpacking.expression());
           if (unpackedExpr instanceof DictionaryLiteral dictLiteral) {
             extractFromSetupConfigDict(dictLiteral);
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/SonarLintPythonIndexer.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/SonarLintPythonIndexer.java
index 75eadc1848..6279d58d84 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/SonarLintPythonIndexer.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/SonarLintPythonIndexer.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,17 +16,24 @@
  */
 package org.sonar.plugins.python.indexer;
 
+import com.google.common.annotations.VisibleForTesting;
+import java.io.File;
 import java.io.IOException;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
 import javax.annotation.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.sonar.api.batch.fs.FileSystem;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.sensor.SensorContext;
+import org.sonar.api.config.Configuration;
 import org.sonar.plugins.python.Python;
 import org.sonar.plugins.python.api.SonarLintCache;
 import org.sonar.plugins.python.api.caching.CacheContext;
@@ -41,15 +48,22 @@
 import org.sonarsource.sonarlint.plugin.api.module.file.ModuleFileListener;
 import org.sonarsource.sonarlint.plugin.api.module.file.ModuleFileSystem;
 
+import static org.sonar.python.semantic.SymbolUtils.resolvedPath;
+
 @SonarLintSide(lifespan = "MODULE")
 public class SonarLintPythonIndexer extends PythonIndexer implements ModuleFileListener {
 
   private final ModuleFileSystem moduleFileSystem;
 
   private CacheContext cacheContext;
-  private final Map indexedFiles = new HashMap<>();
+  private @Nullable FileSystem fileSystem;
+  private @Nullable Configuration configuration;
+  private final PackageRootState packageRootState = new PackageRootState();
+  private final Map knownMainFiles = new ConcurrentHashMap<>();
+  private final Map indexedFiles = new ConcurrentHashMap<>();
   private static final Logger LOG = LoggerFactory.getLogger(SonarLintPythonIndexer.class);
   private boolean shouldBuildProjectSymbolTable = true;
+  private boolean indexingEnabled = true;
   private static final long DEFAULT_MAX_LINES_FOR_INDEXING = 300_000;
   private static final String MAX_LINES_PROPERTY = "sonar.python.sonarlint.indexing.maxlines";
 
@@ -63,8 +77,10 @@ public void buildOnce(SensorContext context) {
     if (!shouldBuildProjectSymbolTable) {
       return;
     }
-    this.projectBaseDirAbsolutePath = context.fileSystem().baseDir().getAbsolutePath();
-    this.packageRoots = resolvePackageRoots(context);
+    this.fileSystem = context.fileSystem();
+    this.configuration = context.config();
+    List rootContributorFiles = getPackageRootContributorFiles(moduleFileSystem);
+    setPackageResolutionResult(PackageRootResolver.resolve(fileSystem, configuration, rootContributorFiles));
     shouldBuildProjectSymbolTable = false;
     List files = getInputFiles(moduleFileSystem);
     collectPackageNames(files);
@@ -74,8 +90,13 @@ public void buildOnce(SensorContext context) {
       // Avoid performance issues for large projects
       LOG.debug("Project symbol table deactivated due to project size (total number of lines is {}, maximum for indexing is {})", nLines, maxLinesForIndexing);
       LOG.debug("Update \"sonar.python.sonarlint.indexing.maxlines\" to set a different limit.");
+      indexingEnabled = false;
       return;
     }
+    files.stream()
+      .map(PythonInputFile::wrappedFile)
+      .forEach(file -> knownMainFiles.put(file.absolutePath(), file));
+    packageRootState.initialize(rootContributorFiles);
     LOG.debug("Input files for indexing: {}", files);
     // computes "globalSymbolsByModuleName"
     GlobalSymbolsScanner globalSymbolsStep = new GlobalSymbolsScanner(context);
@@ -115,6 +136,246 @@ private static List getInputFiles(ModuleFileSystem moduleFileSy
     return Collections.unmodifiableList(files);
   }
 
+  private static List getPackageRootContributorFiles(ModuleFileSystem moduleFileSystem) {
+    return moduleFileSystem.files()
+      .filter(file -> Python.KEY.equals(file.language()))
+      .toList();
+  }
+
+  @VisibleForTesting
+  boolean refreshPackageRoots() {
+    if (fileSystem == null || configuration == null) {
+      return false;
+    }
+    try {
+      PackageResolutionResult result = PackageRootResolver.resolve(fileSystem, configuration, packageRootState.contributorFiles());
+      boolean rootsChanged = !packageRoots.equals(result.roots());
+      setPackageResolutionResult(result);
+      packageRootState.onResolutionSucceeded(this::packageRootCandidate);
+      return rootsChanged;
+    } catch (RuntimeException e) {
+      // This module-scoped indexer survives failed events. Contributor state may already reflect the event while
+      // resolved roots or candidates do not, so require full resolution before handling another structural event.
+      packageRootState.onResolutionFailed();
+      throw e;
+    }
+  }
+
+  private @Nullable Path packageRootCandidate(InputFile file) {
+    if (fileSystem == null || file.file().getParentFile() == null) {
+      return null;
+    }
+    String candidateRoot = PackageRootResolver.adjustPackageRoot(file.file().getParentFile(), fileSystem.baseDir());
+    return resolvedPath(new File(candidateRoot));
+  }
+
+  private void rebuildProjectIndex() {
+    clearProjectIndex();
+    List filesToRebuild = knownMainFiles.values().stream()
+      .map(PythonInputFileImpl::new)
+      .toList();
+    collectPackageNames(filesToRebuild);
+    for (PythonInputFile inputFile : filesToRebuild) {
+      try {
+        super.addFile(inputFile);
+        indexedFiles.put(inputFile.wrappedFile().absolutePath(), inputFile.wrappedFile());
+      } catch (Exception e) {
+        LOG.debug("Failed to re-index file \"{}\" during project index rebuild", inputFile.wrappedFile().filename(), e);
+      }
+    }
+    recreateProjectLevelTypeTable();
+  }
+
+  private PackageRootImpact packageRootImpact(PythonInputFile target, ModuleFileEvent.Type type) {
+    Path candidateRoot = type == ModuleFileEvent.Type.CREATED ? packageRootCandidate(target.wrappedFile()) : null;
+    if (isPackageConfigurationFile(target.wrappedFile().filename())) {
+      return new PackageRootImpact(true, candidateRoot);
+    }
+    if (type == ModuleFileEvent.Type.MODIFIED) {
+      return new PackageRootImpact(false, null);
+    }
+    if (packageRootState.resolutionRetryRequired() || isPackageInitFile(target.wrappedFile().filename())) {
+      return new PackageRootImpact(true, candidateRoot);
+    }
+    if (type == ModuleFileEvent.Type.CREATED) {
+      return createdFilePackageRootImpact(target.wrappedFile(), candidateRoot);
+    }
+    if (type == ModuleFileEvent.Type.DELETED) {
+      return deletedFilePackageRootImpact(target.wrappedFile());
+    }
+    return new PackageRootImpact(true, candidateRoot);
+  }
+
+  private PackageRootImpact createdFilePackageRootImpact(InputFile target, @Nullable Path candidateRoot) {
+    boolean canImpactRoots = candidateRoot == null
+      || canIntroduceConventionalFolder(target)
+      || (!isCoveredByBaseDirFallback(target) && !isResolvedPackageRoot(candidateRoot));
+    return new PackageRootImpact(canImpactRoots, candidateRoot);
+  }
+
+  private PackageRootImpact deletedFilePackageRootImpact(InputFile target) {
+    File parentDirectory = target.file().getParentFile();
+    if (parentDirectory == null || !parentDirectory.isDirectory()) {
+      return new PackageRootImpact(true, null);
+    }
+    if (isCoveredByBaseDirFallback(target)) {
+      return new PackageRootImpact(false, null);
+    }
+    return new PackageRootImpact(packageRootState.deletionCanImpactRoots(target.absolutePath(), this::isResolvedPackageRoot), null);
+  }
+
+  private static boolean isPackageConfigurationFile(String filename) {
+    return "setup.py".equals(filename) || "pyproject.toml".equals(filename);
+  }
+
+  private static boolean isPackageInitFile(String filename) {
+    return "__init__.py".equals(filename);
+  }
+
+  private boolean canIntroduceConventionalFolder(InputFile target) {
+    if (fileSystem == null || packageResolutionResult == null) {
+      return true;
+    }
+    PackageResolutionResult.PrimaryResolutionMethod method = packageResolutionResult.method();
+    if (method != PackageResolutionResult.PrimaryResolutionMethod.BASE_DIR
+      && method != PackageResolutionResult.PrimaryResolutionMethod.SONAR_SOURCES) {
+      return false;
+    }
+    Path targetPath = resolvedPath(target.file());
+    Path baseDirPath = resolvedPath(fileSystem.baseDir());
+    return PackageRootResolver.CONVENTIONAL_FOLDERS.stream()
+      .map(baseDirPath::resolve)
+      .anyMatch(targetPath::startsWith);
+  }
+
+  private boolean isCoveredByBaseDirFallback(InputFile target) {
+    return fileSystem != null
+      && packageResolutionResult != null
+      && packageResolutionResult.method() == PackageResolutionResult.PrimaryResolutionMethod.BASE_DIR
+      && isUnderResolvedPackageRoot(resolvedPath(target.file()));
+  }
+
+  /**
+   * Tracks the Python files that contribute to package-root resolution and caches each file's candidate legacy root
+   * (the root obtained by walking up its parent directories while they contain an {@code __init__.py} file).
+   *
+   * 
                  The candidate cache allows ordinary file events to skip full package-root resolution when the event cannot add
+   * or remove a resolved root. Structural changes such as creating or deleting an {@code __init__.py} invalidate the
+   * cache so that subsequent events remain conservative.
+   */
+  private static final class PackageRootState {
+    private final Map contributorFiles = new ConcurrentHashMap<>();
+    private final Map candidates = new ConcurrentHashMap<>();
+    private boolean candidatesValid;
+    private boolean resolutionRetryRequired;
+
+    void initialize(List files) {
+      contributorFiles.clear();
+      files.forEach(file -> contributorFiles.put(file.absolutePath(), file));
+      candidates.clear();
+      candidatesValid = false;
+      resolutionRetryRequired = false;
+    }
+
+    List contributorFiles() {
+      return List.copyOf(contributorFiles.values());
+    }
+
+    /** Marks that root resolution failed so subsequent structural file events retry it instead of using cached state. */
+    void onResolutionFailed() {
+      resolutionRetryRequired = true;
+    }
+
+    /**
+     * Synchronizes the candidate cache after successful root resolution and allows structural file events to use it
+     * again. This must only be called after the new resolution result has been installed.
+     */
+    void onResolutionSucceeded(Function candidateResolver) {
+      if (candidatesValid) {
+        resolutionRetryRequired = false;
+        return;
+      }
+      candidates.clear();
+      for (Map.Entry entry : contributorFiles.entrySet()) {
+        Path candidate = candidateResolver.apply(entry.getValue());
+        if (candidate == null) {
+          resolutionRetryRequired = false;
+          return;
+        }
+        candidates.put(entry.getKey(), candidate);
+      }
+      candidatesValid = true;
+      resolutionRetryRequired = false;
+    }
+
+    boolean resolutionRetryRequired() {
+      return resolutionRetryRequired;
+    }
+
+    boolean deletionCanImpactRoots(String absolutePath, Predicate isResolvedPackageRoot) {
+      if (!candidatesValid) {
+        return true;
+      }
+      Path previousCandidate = candidates.get(absolutePath);
+      if (previousCandidate == null || !isResolvedPackageRoot.test(previousCandidate)) {
+        return previousCandidate == null;
+      }
+      return candidates.entrySet().stream()
+        .noneMatch(entry -> !entry.getKey().equals(absolutePath) && entry.getValue().equals(previousCandidate));
+    }
+
+    void update(PythonInputFile target, ModuleFileEvent.Type type, @Nullable Path candidate) {
+      InputFile file = target.wrappedFile();
+      String absolutePath = file.absolutePath();
+      if (isPackageInitFile(file.filename())
+        && (type == ModuleFileEvent.Type.CREATED || type == ModuleFileEvent.Type.DELETED)) {
+        candidatesValid = false;
+      }
+      if (isCreatedOrModified(type)) {
+        contributorFiles.put(absolutePath, file);
+        if (type == ModuleFileEvent.Type.CREATED) {
+          if (candidate != null) {
+            candidates.put(absolutePath, candidate);
+          } else {
+            candidatesValid = false;
+          }
+        }
+      } else if (type == ModuleFileEvent.Type.DELETED) {
+        contributorFiles.remove(absolutePath);
+        candidates.remove(absolutePath);
+      }
+    }
+  }
+
+  private record PackageRootImpact(boolean canImpactRoots, @Nullable Path candidateRoot) {
+  }
+
+  private void updateKnownMainFile(PythonInputFile target, ModuleFileEvent.Type type, boolean mainPythonFile) {
+    String absolutePath = target.wrappedFile().absolutePath();
+    boolean wasKnownMainFile = knownMainFiles.containsKey(absolutePath);
+    boolean shouldRemoveFromIndex = type.equals(ModuleFileEvent.Type.DELETED)
+      || type.equals(ModuleFileEvent.Type.MODIFIED)
+      || !mainPythonFile;
+    if (wasKnownMainFile && shouldRemoveFromIndex) {
+      removeFile(target);
+    }
+    if (mainPythonFile && isCreatedOrModified(type)) {
+      knownMainFiles.put(absolutePath, target.wrappedFile());
+    } else if (type.equals(ModuleFileEvent.Type.DELETED) || !mainPythonFile) {
+      knownMainFiles.remove(absolutePath);
+    }
+  }
+
+  private void addFileIfCreatedOrModified(PythonInputFile target, ModuleFileEvent.Type type) throws IOException {
+    if (isCreatedOrModified(type)) {
+      addFile(target);
+    }
+  }
+
+  private static boolean isCreatedOrModified(ModuleFileEvent.Type type) {
+    return type.equals(ModuleFileEvent.Type.CREATED) || type.equals(ModuleFileEvent.Type.MODIFIED);
+  }
+
   @Override
   void addFile(PythonInputFile inputFile) throws IOException {
     super.addFile(inputFile);
@@ -130,23 +391,41 @@ void removeFile(PythonInputFile inputFile) {
   }
 
   @Override
-  public void process(ModuleFileEvent moduleFileEvent) {
+  protected void clearProjectIndex() {
+    super.clearProjectIndex();
+    indexedFiles.clear();
+  }
+
+  @Override
+  public synchronized void process(ModuleFileEvent moduleFileEvent) {
     PythonInputFile target = new PythonInputFileImpl(moduleFileEvent.getTarget());
     String language = target.wrappedFile().language();
-    if (language == null || !language.equals(Python.KEY)) {
+    boolean packageConfigurationFile = isPackageConfigurationFile(target.wrappedFile().filename());
+    boolean pythonFile = Python.KEY.equals(language);
+    boolean mainPythonFile = pythonFile && target.wrappedFile().type() == InputFile.Type.MAIN;
+    if (!pythonFile && !packageConfigurationFile) {
       LOG.debug("Module file event for {} has been ignored because it's not a Python file.", target);
       return;
     }
-    ModuleFileEvent.Type type = moduleFileEvent.getType();
-    if (type.equals(ModuleFileEvent.Type.DELETED) || type.equals(ModuleFileEvent.Type.MODIFIED)) {
-      removeFile(target);
+    if (!indexingEnabled) {
+      return;
     }
-    if (type.equals(ModuleFileEvent.Type.CREATED) || type.equals(ModuleFileEvent.Type.MODIFIED)) {
-      try {
-        addFile(target);
-      } catch (IOException e) {
-        LOG.debug("Failed to load file \"{}\" ({}) to the project symbol table", target.wrappedFile().filename(), type);
+    ModuleFileEvent.Type type = moduleFileEvent.getType();
+    try {
+      PackageRootImpact packageRootImpact = packageRootImpact(target, type);
+      if (pythonFile) {
+        packageRootState.update(target, type, packageRootImpact.candidateRoot());
+        updateKnownMainFile(target, type, mainPythonFile);
+      }
+
+      if (packageRootImpact.canImpactRoots() && refreshPackageRoots()) {
+        rebuildProjectIndex();
+      } else if (mainPythonFile) {
+        addFileIfCreatedOrModified(target, type);
       }
+    } catch (Exception e) {
+      indexedFiles.remove(target.wrappedFile().absolutePath());
+      LOG.debug("Failed to load file \"{}\" ({}) to the project symbol table", target.wrappedFile().filename(), type, e);
     }
   }
 }
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/SonarQubePythonIndexer.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/SonarQubePythonIndexer.java
index f4c554e77e..f3af3baa20 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/SonarQubePythonIndexer.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/SonarQubePythonIndexer.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -31,6 +31,7 @@
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.sensor.SensorContext;
 import org.sonar.plugins.python.PythonInputFile;
+import org.sonar.plugins.python.TestSourceConfiguration;
 import org.sonar.plugins.python.api.caching.CacheContext;
 import org.sonar.plugins.python.caching.Caching;
 import org.sonar.python.index.Descriptor;
@@ -53,6 +54,8 @@ public class SonarQubePythonIndexer extends PythonIndexer {
   private static final Logger LOG = LoggerFactory.getLogger(SonarQubePythonIndexer.class);
 
   private final Caching caching;
+  private final boolean testSourcesConfigured;
+  private boolean analysisOptimized = false;
   private final Set fullySkippableFiles = new HashSet<>();
   private final Set partiallySkippableFiles = new HashSet<>();
   private final List inputFiles = new ArrayList<>();
@@ -60,9 +63,14 @@ public class SonarQubePythonIndexer extends PythonIndexer {
 
   public SonarQubePythonIndexer(List inputFiles, CacheContext cacheContext, SensorContext context, ProjectConfigurationBuilder projectConfigurationBuilder) {
     super(projectConfigurationBuilder);
-    this.projectBaseDirAbsolutePath = context.fileSystem().baseDir().getAbsolutePath();
+    // Package roots are resolved once from the current filesystem, which already reflects all
+    // PR changes (including __init__.py additions or deletions). All FQNs computed below use
+    // these roots, so they remain consistent for the entire analysis run — no mid-run
+    // recomputation is needed. This differs from SonarLint, which must refresh roots on every
+    // incremental file event because its indexer persists across multiple analysis runs.
     this.packageRoots = resolvePackageRoots(context);
     this.caching = new Caching(cacheContext, getCacheVersion(context));
+    this.testSourcesConfigured = TestSourceConfiguration.isConfigured(context.config());
     inputFiles.forEach(f -> {
       this.inputFiles.add(f);
       inputFileToFQN.put(f, SymbolUtils.fullyQualifiedModuleName(packageName(f), f.wrappedFile().filename()));
@@ -78,6 +86,7 @@ public void buildOnce(SensorContext context) {
     analyzeNamespacePackages(projectTree);
 
     if (shouldOptimizeAnalysis(context)) {
+      analysisOptimized = true;
       computeGlobalSymbolsUsingCache(context);
       return;
     }
@@ -96,10 +105,16 @@ public void postAnalysis(SensorContext context) {
     }
   }
 
+  @Override
+  public boolean isAnalysisOptimized() {
+    return analysisOptimized;
+  }
+
   private boolean shouldOptimizeAnalysis(SensorContext context) {
     return caching.isCacheEnabled()
       && (context.canSkipUnchangedFiles() || context.config().getBoolean(SONAR_CAN_SKIP_UNCHANGED_FILES_KEY).orElse(false))
-      && caching.isCacheVersionUpToDate();
+      && caching.isCacheVersionUpToDate()
+      && caching.isTestSourcesConfiguredUnchanged(testSourcesConfigured);
   }
 
   private void computeGlobalSymbolsUsingCache(SensorContext context) {
@@ -161,7 +176,7 @@ private boolean tryToUseCache(Map> importsByModule, PythonIn
     }
     Set descriptors = caching.readProjectLevelSymbolTableEntry(inputFile.wrappedFile().key());
     if (descriptors != null && imports != null) {
-      saveRetrievedDescriptors(inputFile.wrappedFile().key(), descriptors, caching);
+      saveRetrievedDescriptors(inputFile.wrappedFile().key(), currFQN, descriptors, caching);
       return true;
     }
 
@@ -179,8 +194,8 @@ private boolean fileIsUnchanged(PythonInputFile inputFile) {
     return MessageDigest.isEqual(fileHash, fileInputHash);
   }
 
-  private void saveRetrievedDescriptors(String fileKey, Set descriptors, Caching caching) {
-    projectLevelSymbolTable().insertEntry(fileKey, descriptors);
+  private void saveRetrievedDescriptors(String fileKey, String moduleFQN, Set descriptors, Caching caching) {
+    projectLevelSymbolTable().insertEntry(moduleFQN, descriptors);
     caching.copyFromPrevious(fileKey);
   }
 
@@ -192,6 +207,7 @@ public void computeGlobalSymbols(List files, SensorContext cont
       saveMainFilesListInCache(new HashSet<>(inputFileToFQN.values()));
       // Information on used Typeshed stubs needs to be done at the end of the analysis, as it is not computed during indexing anymore
       caching.writeCacheVersion();
+      caching.writeTestSourcesConfigured(testSourcesConfigured);
     }
   }
 
@@ -241,6 +257,18 @@ public CacheContext cacheContext() {
     return caching.cacheContext();
   }
 
+  @Override
+  public void writeEffectiveFileType(String fileKey, InputFile.Type type) {
+    if (caching.isCacheEnabled()) {
+      caching.writeEffectiveFileType(fileKey, type);
+    }
+  }
+
+  @Override
+  public InputFile.Type readEffectiveFileType(String fileKey) {
+    return caching.readEffectiveFileType(fileKey);
+  }
+
   private static String getCacheVersion(SensorContext context) {
     String implementationVersion = getImplementationVersion(SonarQubePythonIndexer.class);
     var pythonVersions = context.config().getStringArray(PYTHON_VERSION_KEY);
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/indexer/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/indexer/package-info.java
index df040759d1..d9fc2e1bf4 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/indexer/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/indexer/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/mypy/MypyRulesDefinition.java b/python-commons/src/main/java/org/sonar/plugins/python/mypy/MypyRulesDefinition.java
index ad5f218f27..c6310d66c6 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/mypy/MypyRulesDefinition.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/mypy/MypyRulesDefinition.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/mypy/MypySensor.java b/python-commons/src/main/java/org/sonar/plugins/python/mypy/MypySensor.java
index ce3c25934e..72d65efdce 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/mypy/MypySensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/mypy/MypySensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/mypy/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/mypy/package-info.java
index eb82845e0c..f5ccae0cae 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/mypy/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/mypy/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/nosonar/NoSonarIssueFilter.java b/python-commons/src/main/java/org/sonar/plugins/python/nosonar/NoSonarIssueFilter.java
index b398e5c0be..37db0a7db5 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/nosonar/NoSonarIssueFilter.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/nosonar/NoSonarIssueFilter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -33,9 +33,11 @@ public class NoSonarIssueFilter implements IssueFilter {
   private static final Set WHITELISTED_RULES = Set.of("S1309", "NoSonar");
 
   private final NoSonarLineInfoCollector noSonarLineInfoCollector;
+  private final SecurityRuleKeyProvider securityRuleKeyProvider;
 
-  public NoSonarIssueFilter(NoSonarLineInfoCollector noSonarLineInfoCollector) {
+  public NoSonarIssueFilter(NoSonarLineInfoCollector noSonarLineInfoCollector, SecurityRuleKeyProvider securityRuleKeyProvider) {
     this.noSonarLineInfoCollector = noSonarLineInfoCollector;
+    this.securityRuleKeyProvider = securityRuleKeyProvider;
   }
 
   @Override
@@ -51,25 +53,28 @@ public boolean accept(FilterableIssue issue, IssueFilterChain chain) {
     String ruleId = issue.ruleKey().rule();
 
     if(WHITELISTED_RULES.contains(ruleId)) {
-      LOG.debug("Rule {} cannot be filtered out as it is whitelisted (all whitelisted rules: {}) for component with key: {} on line: {}", 
-        ruleId, 
+      LOG.debug("Rule {} cannot be filtered out as it is whitelisted (all whitelisted rules: {}) for component with key: {} on line: {}",
+        ruleId,
         WHITELISTED_RULES,
-        issueComponentKey, 
+        issueComponentKey,
         issueLine);
 
       // while whitelisted rules should never be filtered out, returning true here screws up the LITs plugin
-      return chain.accept(issue); 
+      return chain.accept(issue);
     }
 
-    var isNotFilteredOutByNoSonar = noSonarLineInfo == null || 
-      (!noSonarLineInfo.isSuppressedRuleKeysEmpty() && !noSonarLineInfo.suppressedRuleKeys().contains(ruleId));
-    if (!isNotFilteredOutByNoSonar) {
+    var isSuppressedByNoSonar = noSonarLineInfo != null && (
+      (noSonarLineInfo.isSuppressedRuleKeysEmpty() && !noSonarLineInfo.securityOnlySuppression())
+      || noSonarLineInfo.suppressedRuleKeys().contains(ruleId)
+      || (noSonarLineInfo.securityOnlySuppression() && securityRuleKeyProvider.isSecurityRule(ruleId))
+    );
+    if (isSuppressedByNoSonar) {
       LOG.debug("Filtering out issue in the component with key: {} for rule: {} on line: {} based on the file NoSonar infos {}",
         issueComponentKey,
         issue.ruleKey().rule(),
         issueLine,
         noSonarLineInfos.values());
     }
-    return isNotFilteredOutByNoSonar && chain.accept(issue);
+    return !isSuppressedByNoSonar && chain.accept(issue);
   }
 }
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/nosonar/NoSonarLineInfoCollector.java b/python-commons/src/main/java/org/sonar/plugins/python/nosonar/NoSonarLineInfoCollector.java
index 959f272310..a0f255b42b 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/nosonar/NoSonarLineInfoCollector.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/nosonar/NoSonarLineInfoCollector.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/nosonar/SecurityRuleKeyProvider.java b/python-commons/src/main/java/org/sonar/plugins/python/nosonar/SecurityRuleKeyProvider.java
new file mode 100644
index 0000000000..c39f1b14e6
--- /dev/null
+++ b/python-commons/src/main/java/org/sonar/plugins/python/nosonar/SecurityRuleKeyProvider.java
@@ -0,0 +1,163 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.nosonar;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import java.io.File;
+import java.io.IOException;
+import java.net.JarURLConnection;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Set;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.sonar.api.scanner.ScannerSide;
+import org.sonarsource.api.sonarlint.SonarLintSide;
+
+@ScannerSide
+@SonarLintSide
+public class SecurityRuleKeyProvider {
+
+  private static final Logger LOG = LoggerFactory.getLogger(SecurityRuleKeyProvider.class);
+
+  private static final String JSON_EXTENSION = ".json";
+
+  private static final String[] RULE_RESOURCE_DIRS = {
+    "org/sonar/l10n/py/rules/python/",
+    "com/sonar/l10n/py/rules/python/"
+  };
+
+  private final Set securityRuleKeys;
+
+  public SecurityRuleKeyProvider() {
+    this(SecurityRuleKeyProvider.class.getClassLoader());
+  }
+
+  SecurityRuleKeyProvider(ClassLoader classLoader) {
+    securityRuleKeys = Collections.unmodifiableSet(loadSecurityRuleKeys(classLoader));
+  }
+
+  SecurityRuleKeyProvider(Set securityRuleKeys) {
+    this.securityRuleKeys = Collections.unmodifiableSet(new HashSet<>(securityRuleKeys));
+  }
+
+  public boolean isSecurityRule(String ruleKey) {
+    return securityRuleKeys.contains(ruleKey);
+  }
+
+  private static Set loadSecurityRuleKeys(ClassLoader classLoader) {
+    var keys = new HashSet();
+    for (var dir : RULE_RESOURCE_DIRS) {
+      try {
+        Enumeration resources = classLoader.getResources(dir);
+        while (resources.hasMoreElements()) {
+          scanDir(resources.nextElement(), keys);
+        }
+      } catch (IOException e) {
+        LOG.warn("Failed to scan security rule keys from classpath path: {}", dir, e);
+      }
+    }
+    LOG.debug("Loaded {} security rule key(s)", keys.size());
+    return keys;
+  }
+
+  private static void scanDir(URL dirUrl, Set keys) {
+    try {
+      if ("jar".equals(dirUrl.getProtocol())) {
+        scanJar(dirUrl, keys);
+      } else if ("file".equals(dirUrl.getProtocol())) {
+        scanFileDir(dirUrl, keys);
+      }
+    } catch (IOException | URISyntaxException | RuntimeException e) {
+      LOG.debug("Could not scan {} for security rule keys: {}", dirUrl, e.getMessage());
+    }
+  }
+
+  private static void scanJar(URL jarDirUrl, Set keys) throws IOException {
+    var urlConnection = jarDirUrl.openConnection();
+    if (!(urlConnection instanceof JarURLConnection connection)) {
+      LOG.debug("Skipping jar URL {} — unexpected connection type: {}", jarDirUrl, urlConnection.getClass().getName());
+      return;
+    }
+    var entryPrefix = connection.getEntryName();
+    if (entryPrefix == null) {
+      LOG.debug("Skipping jar URL {} — no entry name", jarDirUrl);
+      return;
+    }
+    connection.setUseCaches(false);
+    try (var jar = connection.getJarFile()) {
+      var entries = jar.entries();
+      while (entries.hasMoreElements()) {
+        var entry = entries.nextElement();
+        if (!entry.isDirectory() && entry.getName().startsWith(entryPrefix)) {
+          var suffix = entry.getName().substring(entryPrefix.length());
+          if (!suffix.contains("/") && suffix.endsWith(JSON_EXTENSION)) {
+            try (var is = jar.getInputStream(entry)) {
+              var json = new String(is.readAllBytes(), StandardCharsets.UTF_8);
+              if (isSecurityRuleJson(json)) {
+                keys.add(extractRuleKey(entry.getName()));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private static void scanFileDir(URL dirUrl, Set keys) throws IOException, URISyntaxException {
+    var dir = new File(dirUrl.toURI());
+    if (!dir.isDirectory()) {
+      return;
+    }
+    var jsonFiles = dir.listFiles((d, name) -> name.endsWith(JSON_EXTENSION));
+    if (jsonFiles == null) {
+      return;
+    }
+    for (var jsonFile : jsonFiles) {
+      var json = Files.readString(jsonFile.toPath(), StandardCharsets.UTF_8);
+      if (isSecurityRuleJson(json)) {
+        keys.add(extractRuleKey(jsonFile.getName()));
+      }
+    }
+  }
+
+  private static boolean isSecurityRuleJson(String json) {
+    try {
+      JsonObject obj = JsonParser.parseString(json).getAsJsonObject();
+      var typeElement = obj.get("type");
+      if (typeElement == null) {
+        return false;
+      }
+      var type = typeElement.getAsString();
+      return "VULNERABILITY".equals(type);
+    } catch (Exception e) {
+      return false;
+    }
+  }
+
+  private static String extractRuleKey(String pathOrName) {
+    var lastSlash = pathOrName.lastIndexOf('/');
+    var filename = lastSlash >= 0 ? pathOrName.substring(lastSlash + 1) : pathOrName;
+    return filename.substring(0, filename.length() - JSON_EXTENSION.length());
+  }
+}
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/nosonar/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/nosonar/package-info.java
index aec7fac264..5f3d394ef9 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/nosonar/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/nosonar/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/package-info.java
index 4309be6908..f7731e1fc7 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/parser/StaxParser.java b/python-commons/src/main/java/org/sonar/plugins/python/parser/StaxParser.java
index 3abb292483..c8898561a2 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/parser/StaxParser.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/parser/StaxParser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/parser/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/parser/package-info.java
index 07e17125ea..7a13469ea1 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/parser/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/parser/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/pylint/PylintRulesDefinition.java b/python-commons/src/main/java/org/sonar/plugins/python/pylint/PylintRulesDefinition.java
index 2323090215..525b4cc0d6 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/pylint/PylintRulesDefinition.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/pylint/PylintRulesDefinition.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/pylint/PylintSensor.java b/python-commons/src/main/java/org/sonar/plugins/python/pylint/PylintSensor.java
index c7905b1f9f..7d24779116 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/pylint/PylintSensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/pylint/PylintSensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/pylint/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/pylint/package-info.java
index ee90ed8719..61a88ae004 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/pylint/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/pylint/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffJsonReportReader.java b/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffJsonReportReader.java
index 07ac2c8869..8b6b073cda 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffJsonReportReader.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffJsonReportReader.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffRulesDefinition.java b/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffRulesDefinition.java
index 1360f1f117..7da62169da 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffRulesDefinition.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffRulesDefinition.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffSensor.java b/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffSensor.java
index f1c4fd63d4..bc7cf73ebd 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffSensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/ruff/RuffSensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,9 +20,14 @@
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.sonar.api.batch.fs.FileSystem;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.rule.Severity;
 import org.sonar.api.batch.sensor.SensorContext;
@@ -70,18 +75,21 @@ protected void importReport(File reportPath, SensorContext context, Set
     throws IOException, ParseException {
     InputStream in = new FileInputStream(reportPath);
     LOG.info("Importing {}", reportPath);
-    RuffJsonReportReader.read(in, issue -> saveIssue(context, issue, unresolvedInputFiles));
+    // Built lazily and reused across all issues of this report, so the fallback below never re-scans the
+    // filesystem per issue.
+    RelativePathIndex relativePathIndex = new RelativePathIndex(context.fileSystem());
+    RuffJsonReportReader.read(in, issue -> saveIssue(context, issue, unresolvedInputFiles, relativePathIndex));
   }
 
   private static void saveIssue(SensorContext context, RuffJsonReportReader.Issue issue,
-    Set unresolvedInputFiles) {
+    Set unresolvedInputFiles, RelativePathIndex relativePathIndex) {
     if (isEmpty(issue.ruleKey) || isEmpty(issue.filePath) || isEmpty(issue.message)) {
       LOG.debug("Missing information for ruleKey:'{}', filePath:'{}', message:'{}'", issue.ruleKey, issue.filePath,
         issue.message);
       return;
     }
 
-    InputFile inputFile = context.fileSystem().inputFile(context.fileSystem().predicates().hasPath(issue.filePath));
+    InputFile inputFile = findInputFile(context.fileSystem(), issue.filePath, relativePathIndex);
     if (inputFile == null) {
       unresolvedInputFiles.add(issue.filePath);
       return;
@@ -111,6 +119,87 @@ private static void saveIssue(SensorContext context, RuffJsonReportReader.Issue
     newExternalIssue.ruleId(issue.ruleKey).save();
   }
 
+  /**
+   * Ruff only reports absolute file paths, which may have been computed with a different base directory than the
+   * one used for the current analysis (e.g. report generated in CI, analysis run locally, or vice versa).
+   * When the direct lookup fails, fall back to matching the report path against the relative path of an indexed
+   * file, disregarding the base directory, through the {@link RelativePathIndex}.
+   */
+  private static InputFile findInputFile(FileSystem fileSystem, String filePath, RelativePathIndex relativePathIndex) {
+    InputFile inputFile = fileSystem.inputFile(fileSystem.predicates().hasPath(filePath));
+    if (inputFile != null) {
+      return inputFile;
+    }
+    return relativePathIndex.findByRelativePathSuffix(filePath);
+  }
+
+  /**
+   * Indexes input files by file name so that the suffix-matching fallback only has to compare the (typically few)
+   * files sharing the same name, instead of scanning every indexed file for every unresolved issue. Built lazily,
+   * on first use, and reused for the whole report.
+   * 
                  
+   * Among several candidates sharing the report path's file name, the one whose relative path is the longest
+   * matching suffix is preferred, since it pins down the project base directory boundary more precisely than a
+   * shorter, coincidental match (e.g. a root-level {@code __init__.py} trivially suffix-matches every deeper
+   * {@code __init__.py} report path). Candidates matching an equally long suffix are rejected as ambiguous.
+   * 
                  
+   * This remains a best-effort heuristic: if the file Ruff actually analyzed isn't indexed at all, the issue can
+   * still be attached to an unrelated file that happens to share its relative path suffix.
+   */
+  private static class RelativePathIndex {
+
+    private final FileSystem fileSystem;
+    private Map> filesByName;
+
+    private RelativePathIndex(FileSystem fileSystem) {
+      this.fileSystem = fileSystem;
+    }
+
+    InputFile findByRelativePathSuffix(String filePath) {
+      if (filesByName == null) {
+        filesByName = buildIndex(fileSystem);
+      }
+      String normalizedFilePath = filePath.replace('\\', '/');
+      List candidates = filesByName.getOrDefault(fileName(normalizedFilePath), List.of());
+
+      InputFile bestMatch = null;
+      int bestMatchLength = -1;
+      boolean ambiguous = false;
+      for (InputFile candidate : candidates) {
+        String relativePath = candidate.relativePath();
+        if (normalizedFilePath.equals(relativePath) || normalizedFilePath.endsWith("/" + relativePath)) {
+          if (relativePath.length() > bestMatchLength) {
+            bestMatch = candidate;
+            bestMatchLength = relativePath.length();
+            ambiguous = false;
+          } else if (relativePath.length() == bestMatchLength) {
+            ambiguous = true;
+          }
+        }
+      }
+      if (ambiguous) {
+        LOG.debug("Multiple files equally match the path '{}', skipping ambiguous match", filePath);
+        return null;
+      }
+      if (bestMatch != null) {
+        LOG.debug("Resolved report path '{}' to '{}' by matching the relative path, ignoring the base directory", filePath, bestMatch);
+      }
+      return bestMatch;
+    }
+
+    private static Map> buildIndex(FileSystem fileSystem) {
+      Map> index = new HashMap<>();
+      for (InputFile inputFile : fileSystem.inputFiles(fileSystem.predicates().all())) {
+        index.computeIfAbsent(fileName(inputFile.relativePath()), k -> new ArrayList<>()).add(inputFile);
+      }
+      return index;
+    }
+
+    private static String fileName(String path) {
+      return path.substring(path.lastIndexOf('/') + 1);
+    }
+  }
+
   /*
    * The end location column should be after the start location col
    */
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/ruff/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/ruff/package-info.java
index ee0b6790df..31fb5de5f8 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/ruff/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/ruff/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/SensorTelemetryStorage.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/SensorTelemetryStorage.java
index 09968fe14d..0e75e8a773 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/SensorTelemetryStorage.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/SensorTelemetryStorage.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/TelemetryMetricKey.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/TelemetryMetricKey.java
index 32a11f005c..ec63fde4f2 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/TelemetryMetricKey.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/TelemetryMetricKey.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -27,6 +27,8 @@ public enum TelemetryMetricKey {
   IPYNB_DATABRICKS_FOUND("python.notebook.databricks.ipynb"),
   PYTHON_DEPENDENCIES("python.dependencies"),
   PYTHON_DEPENDENCIES_FORMAT_VERSION("python.dependencies.format_version"),
+  PYTHON_IMPORTS("python.imports"),
+  PYTHON_IMPORTS_FORMAT_VERSION("python.imports.format_version"),
   NOSONAR_RULE_ID_KEY("python.nosonar.rule_ids"),
   NOSONAR_COMMENTS_KEY("python.nosonar.comments"),
   NOSONAR_NOTEBOOK_RULE_ID_KEY("python.notebook.nosonar.rule_ids"),
@@ -47,6 +49,7 @@ public enum TelemetryMetricKey {
   PYTHON_PACKAGE_RESOLVED_VIA_SONAR_SOURCES("python.packages.resolved_via_sonar_sources"),
   PYTHON_PACKAGE_RESOLVED_VIA_CONVENTIONAL_FOLDERS("python.packages.resolved_via_conventional_folders"),
   PYTHON_PACKAGE_RESOLVED_VIA_BASE_DIR("python.packages.resolved_via_base_dir"),
+  PYTHON_PACKAGE_RESOLVED_VIA_LEGACY_INIT_PY("python.packages.resolved_via_legacy_init_py"),
   // Build system flags (1 = detected, 0 = not detected) - only applicable when pyproject.toml is used
   PYTHON_PACKAGE_BUILD_SYSTEM_SETUPTOOLS("python.packages.build_system.setuptools"),
   PYTHON_PACKAGE_BUILD_SYSTEM_POETRY("python.packages.build_system.poetry"),
@@ -73,7 +76,10 @@ public enum TelemetryMetricKey {
   PYTHON_MAIN_LINES_MISCLASSIFIED_IMPORT_BASED_ONLY("python.lines.main.misclassified_import_based_only"),
   PYTHON_MAIN_FILES_MISCLASSIFIED_PATH_BASED_ONLY("python.files.main.misclassified_path_based_only"),
   PYTHON_MAIN_LINES_MISCLASSIFIED_PATH_BASED_ONLY("python.lines.main.misclassified_path_based_only"),
-  PYTHON_SONAR_TESTS_SET("python.sonar_tests.set");
+  PYTHON_SONAR_TESTS_SET("python.sonar_tests.set"),
+  PYTHON_TEST_FILE_HEURISTIC_TRIGGERED("python.test_file_heuristic.triggered"),
+  PYTHON_ANALYSIS_USES_CACHE("python.analysis.uses_cache"),
+  PYTHON_FILES_SCANNED_WITH_CACHE("python.files.scanned_with_cache");
 
   private final String key;
 
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/ImportsTelemetry.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/ImportsTelemetry.java
new file mode 100644
index 0000000000..dc6a350844
--- /dev/null
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/ImportsTelemetry.java
@@ -0,0 +1,33 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.telemetry.collectors;
+
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ * Telemetry data for top-level module names found in Python import statements.
+ *
+ * @param importedModules Set of normalized top-level module names (e.g. "pandas", "numpy")
+ */
+public record ImportsTelemetry(Set importedModules) {
+
+  public ImportsTelemetry(Set importedModules) {
+    this.importedModules = Collections.unmodifiableSet(importedModules);
+  }
+
+}
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/ImportsTelemetryCollector.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/ImportsTelemetryCollector.java
new file mode 100644
index 0000000000..2f14d6c213
--- /dev/null
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/ImportsTelemetryCollector.java
@@ -0,0 +1,171 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.telemetry.collectors;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import org.sonar.plugins.python.api.tree.AliasedName;
+import org.sonar.plugins.python.api.tree.BaseTreeVisitor;
+import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.plugins.python.api.tree.ImportFrom;
+import org.sonar.plugins.python.api.tree.ImportName;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.dependency.model.Dependency;
+
+/**
+ * Collects top-level module names from Python import statements across all analyzed files.
+ * Thread-safe: may be called from parallel file scans.
+ */
+public class ImportsTelemetryCollector {
+
+  private static final Set PYTHON_STDLIB_MODULES = Set.of(
+    "os", "json", "datetime", "typing", "logging", "sys", "re", "time", "pathlib",
+    "collections", "dataclasses", "uuid", "enum", "urllib", "functools", "io",
+    "argparse", "base64", "contextlib", "asyncio", "subprocess", "hashlib",
+    "tempfile", "threading", "importlib", "math", "abc", "shutil", "traceback",
+    "random", "copy", "types", "csv", "concurrent", "decimal", "itertools", "inspect",
+    "socket", "http", "secrets", "warnings", "string", "zipfile", "ast", "zoneinfo",
+    "glob", "xml", "html", "contextvars", "signal", "hmac", "email", "operator", "ssl",
+    "unicodedata", "gzip", "multiprocessing", "calendar", "textwrap", "pickle",
+    "platform", "struct", "queue", "ipaddress", "statistics", "pprint", "difflib",
+    "mimetypes", "gc", "binascii", "sqlite3", "smtplib", "fnmatch", "atexit",
+    "configparser", "shlex", "getpass", "stat", "builtins", "zlib", "pkgutil",
+    "tarfile", "ctypes", "codecs", "errno", "timeit", "locale", "tkinter",
+    "tracemalloc", "socketserver", "getopt", "optparse", "filecmp", "ftplib",
+    "imaplib", "xmlrpc", "wsgiref", "colorsys", "pdb", "tomllib", "pydoc", "ntpath",
+    "sysconfig", "faulthandler", "site", "msvcrt", "curses", "cprofile", "-future-",
+    "unittest");
+
+  private static final Set PYTHON_PYPI_MODULES = Set.of(
+    "pytest", "requests", "pydantic", "boto3", "fastapi", "pandas", "numpy", "yaml",
+    "dotenv", "httpx", "sqlalchemy", "starlette", "pydantic-settings", "dateutil",
+    "google", "jwt", "uvicorn", "azure", "cryptography", "opentelemetry", "pytz",
+    "redis", "urllib3", "flask", "pil", "pyspark", "openpyxl", "psycopg2", "jinja2",
+    "aiohttp", "typing-extensions", "openai", "tenacity", "structlog", "matplotlib",
+    "sentry-sdk", "setuptools", "alembic", "sklearn", "scipy", "moto", "django",
+    "aws-lambda-powertools", "bs4", "click", "pymongo", "jsonschema", "loguru",
+    "langchain-core", "psutil", "celery", "tqdm", "cachetools", "werkzeug",
+    "prometheus-client", "rest-framework", "pyarrow", "pydantic-core", "freezegun",
+    "lxml", "airflow", "rich", "snowflake", "torch", "docx", "pytest-asyncio",
+    "psycopg", "jose", "pythonjsonlogger", "typer", "bson", "pyodbc", "paramiko",
+    "plotly", "mcp", "apscheduler", "pendulum", "pypdf", "langgraph", "databricks",
+    "polars", "msal", "faker", "langchain-openai", "googleapiclient", "orjson",
+    "cv2", "ddtrace", "playwright", "fitz", "anthropic", "asyncpg", "reportlab",
+    "confluent-kafka", "streamlit", "docker", "langchain-community", "deepdiff",
+    "xgboost", "unidecode", "datadog", "motor", "pika", "github", "kombu", "stripe",
+    "pypdf2", "hypothesis", "colorama", "firebase-admin", "qrcode",
+    "prometheus-fastapi-instrumentator", "ldclient", "pycountry", "pydantic-ai",
+    "flask-wtf", "pandera", "markupsafe", "croniter", "aiobotocore",
+    "langchain-text-splitters", "magic", "aiokafka", "geopandas", "oracledb", "nltk",
+    "onnxruntime", "psycopg-pool", "rest-framework-simplejwt", "aws-xray-sdk",
+    "oauthlib", "pyotp", "tensorflow", "statsmodels", "holidays", "s3fs", "pdf2image",
+    "sqlglot", "attr", "omegaconf", "pytesseract", "decouple", "gevent",
+    "requests-aws4auth", "aws-lambda-typing", "fakeredis", "retry", "twilio",
+    "langchain-aws", "pgvector", "chardet", "dns", "tomli", "mypy-boto3-dynamodb",
+    "spacy", "requests-oauthlib", "hvac", "fpdf", "functions-framework", "aio-pika",
+    "aiocache", "dj-database-url", "schedule", "ujson", "invoke", "keyring",
+    "pypdfium2", "langchain-anthropic", "gnupg", "langsmith", "watchdog",
+    "simple-salesforce", "simple-history", "asgi-correlation-id", "async-lru",
+    "redshift-connector", "datadog-api-client", "uvloop", "markdownify", "langdetect",
+    "faiss", "websocket", "pg8000", "pynamodb", "geoalchemy2", "tldextract",
+    "coverage", "atlassian", "ulid", "flask-caching", "minio", "feedparser",
+    "levenshtein", "mypy-boto3-secretsmanager", "jmespath", "channels", "dateparser",
+    "pygments", "optuna", "dlt", "langchain-mcp-adapters", "debugpy", "numba",
+    "msgpack", "pydantic-extra-types", "oauth2client", "attrs", "pysftp", "xarray",
+    "chromadb", "flask-limiter", "argon2", "wtforms", "json-repair", "opencensus",
+    "mongoengine", "mypy-boto3-ssm", "nh3", "slack-bolt", "llama-index", "prefect",
+    "tornado", "vcr", "pdfkit", "aiosqlite", "docxtpl", "slack", "graphviz",
+    "mongomock", "ray", "deepeval", "pyathena", "aws-msk-iam-sasl-signer",
+    "importlib-metadata", "gcsfs", "assertpy", "docutils", "markitdown", "pip",
+    "inflection", "timezonefinder", "office365", "voluptuous", "pulumi", "tzlocal",
+    "rq", "valkey", "deltalake", "avro", "datadog-lambda", "prettytable",
+    "webdriver-manager", "django-redis", "strenum", "allure", "colorlog", "opik",
+    "nacl", "pikepdf", "cfnresponse", "flask-session", "rasterio", "sympy", "pydub",
+    "pydicom", "ipywidgets", "textual", "uuid-extensions", "keras", "beanie",
+    "mypy-boto3-sns", "flask-jwt-extended", "hamcrest", "python-http-client",
+    "httpcore", "pillow-heif", "pyparsing", "unleashclient", "altair",
+    "starlette-context", "fire", "posthog", "xlwings", "aws-requests-auth",
+    "botocore", "awsglue", "mshell-python-core", "regex", "urllib2");
+
+  private static final Set WHITELIST;
+
+  static {
+    WHITELIST = new HashSet<>(PYTHON_STDLIB_MODULES);
+    WHITELIST.addAll(PYTHON_PYPI_MODULES);
+  }
+
+  private final Set importedModules = ConcurrentHashMap.newKeySet();
+
+  public void collect(FileInput rootTree) {
+    var visitor = new CollectorVisitor();
+    rootTree.accept(visitor);
+    Set collected = visitor.getCollected();
+    collected.retainAll(WHITELIST);
+    importedModules.addAll(collected);
+  }
+
+  public ImportsTelemetry getTelemetry() {
+    return new ImportsTelemetry(importedModules);
+  }
+
+  private static class CollectorVisitor extends BaseTreeVisitor {
+    private final Set collected = new HashSet<>();
+
+    @Override
+    public void visitImportName(ImportName importName) {
+      // import X.Y.Z  ->  top-level is X
+      for (AliasedName aliasedName : importName.modules()) {
+        List names = aliasedName.dottedName().names();
+        if (!names.isEmpty()) {
+          addNormalized(names.get(0).name());
+        }
+      }
+      super.visitImportName(importName);
+    }
+
+    @Override
+    public void visitImportFrom(ImportFrom importFrom) {
+      // Skip relative imports (from . import foo, from ..utils import bar)
+      if (!importFrom.dottedPrefixForModule().isEmpty()) {
+        super.visitImportFrom(importFrom);
+        return;
+      }
+      // module() can be null for bare relative imports
+      if (importFrom.module() == null) {
+        super.visitImportFrom(importFrom);
+        return;
+      }
+      // Collect the top-level module name — works for both regular and wildcard imports
+      List names = importFrom.module().names();
+      if (!names.isEmpty()) {
+        addNormalized(names.get(0).name());
+      }
+      super.visitImportFrom(importFrom);
+    }
+
+    private void addNormalized(String rawName) {
+      // Reuse Dependency normalization (lowercase + [._-]+ -> -)
+      collected.add(new Dependency(rawName).name());
+    }
+
+    Set getCollected() {
+      return collected;
+    }
+  }
+}
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetry.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetry.java
index cb29d0d475..78693e0e15 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetry.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetry.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryCollector.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryCollector.java
index dd627d0368..cd0f1a2393 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryCollector.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryCollector.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetry.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetry.java
index ccf7442120..93b31f0579 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetry.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetry.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetryCollector.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetryCollector.java
index acc151ebbf..45cd052c08 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetryCollector.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetryCollector.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/package-info.java
index 72cfb4ea27..e6bb3dd67f 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/collectors/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/package-info.java
index caecfb169c..fd6649d6c4 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/telemetry/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/telemetry/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/warnings/AnalysisWarningsWrapper.java b/python-commons/src/main/java/org/sonar/plugins/python/warnings/AnalysisWarningsWrapper.java
index 7d503fd8fb..106f93d10c 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/warnings/AnalysisWarningsWrapper.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/warnings/AnalysisWarningsWrapper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/warnings/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/warnings/package-info.java
index 1781ada502..8129152186 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/warnings/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/warnings/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/xunit/PythonXUnitSensor.java b/python-commons/src/main/java/org/sonar/plugins/python/xunit/PythonXUnitSensor.java
index 3fcc5c2105..b48396a19c 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/xunit/PythonXUnitSensor.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/xunit/PythonXUnitSensor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestCase.java b/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestCase.java
index 6a22b27420..8f284c311e 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestCase.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestCase.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestResult.java b/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestResult.java
index 364dbdb55a..ab45741e68 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestResult.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestResult.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestSuite.java b/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestSuite.java
index de4a7d8a3c..2560ced46c 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestSuite.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestSuite.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestSuiteParser.java b/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestSuiteParser.java
index 42b2219442..f7e61f301a 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestSuiteParser.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/xunit/TestSuiteParser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/main/java/org/sonar/plugins/python/xunit/package-info.java b/python-commons/src/main/java/org/sonar/plugins/python/xunit/package-info.java
index 088e9e32d2..7d643c99d2 100644
--- a/python-commons/src/main/java/org/sonar/plugins/python/xunit/package-info.java
+++ b/python-commons/src/main/java/org/sonar/plugins/python/xunit/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/com/sonar/plugins/security/api/PythonRules.java b/python-commons/src/test/java/com/sonar/plugins/security/api/PythonRules.java
index f85ce5f5fc..14458c493a 100644
--- a/python-commons/src/test/java/com/sonar/plugins/security/api/PythonRules.java
+++ b/python-commons/src/test/java/com/sonar/plugins/security/api/PythonRules.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/com/sonarsource/plugins/architecturepythonfrontend/api/ArchitecturePythonRules.java b/python-commons/src/test/java/com/sonarsource/plugins/architecturepythonfrontend/api/ArchitecturePythonRules.java
index ae67e3ca49..4d2c9cf0cf 100644
--- a/python-commons/src/test/java/com/sonarsource/plugins/architecturepythonfrontend/api/ArchitecturePythonRules.java
+++ b/python-commons/src/test/java/com/sonarsource/plugins/architecturepythonfrontend/api/ArchitecturePythonRules.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/com/sonarsource/plugins/dbd/api/PythonRules.java b/python-commons/src/test/java/com/sonarsource/plugins/dbd/api/PythonRules.java
index 2889b9c801..30624cb569 100644
--- a/python-commons/src/test/java/com/sonarsource/plugins/dbd/api/PythonRules.java
+++ b/python-commons/src/test/java/com/sonarsource/plugins/dbd/api/PythonRules.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/AIQualityProfileTest.java b/python-commons/src/test/java/org/sonar/plugins/python/AIQualityProfileTest.java
new file mode 100644
index 0000000000..2cd1c428d8
--- /dev/null
+++ b/python-commons/src/test/java/org/sonar/plugins/python/AIQualityProfileTest.java
@@ -0,0 +1,91 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python;
+
+import com.sonar.plugins.security.api.PythonRules;
+import com.sonarsource.plugins.architecturepythonfrontend.api.ArchitecturePythonRules;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.sonar.api.server.profile.BuiltInQualityProfilesDefinition;
+import org.sonar.api.server.profile.BuiltInQualityProfilesDefinition.BuiltInActiveRule;
+import org.sonar.plugins.python.editions.OpenSourceRepositoryInfoProvider;
+import org.sonar.plugins.python.editions.RepositoryInfoProvider;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class AIQualityProfileTest {
+
+  @BeforeEach
+  void setUp() {
+    PythonRules.throwOnCall = false;
+    PythonRules.getRuleKeys().clear();
+    com.sonarsource.plugins.dbd.api.PythonRules.throwOnCall = false;
+    com.sonarsource.plugins.dbd.api.PythonRules.getDataflowBugDetectionRuleKeys().clear();
+    ArchitecturePythonRules.throwOnCall = false;
+    ArchitecturePythonRules.getRuleKeys().clear();
+  }
+
+  public BuiltInQualityProfilesDefinition.BuiltInQualityProfile getProfile() {
+    BuiltInQualityProfilesDefinition.Context context = new BuiltInQualityProfilesDefinition.Context();
+    new AIQualityProfile(new RepositoryInfoProvider[]{new OpenSourceRepositoryInfoProvider()}).define(context);
+    return context.profile("py", "Sonar agentic AI");
+  }
+
+  @Test
+  void profile() {
+    BuiltInQualityProfilesDefinition.BuiltInQualityProfile profile = getProfile();
+    assertThat(profile.rules()).extracting("repoKey").containsOnly("python");
+    assertThat(profile.rules()).hasSizeGreaterThan(25);
+    assertThat(profile.rules()).extracting(BuiltInActiveRule::ruleKey).contains("S100");
+  }
+
+  @Test
+  void should_contain_security_rules_when_available() {
+    PythonRules.getRuleKeys().add("S3649");
+    try {
+      BuiltInQualityProfilesDefinition.BuiltInQualityProfile profile = getProfile();
+      assertThat(profile.rules()).extracting("repoKey").contains("pythonsecurity");
+      assertThat(profile.rules()).extracting(BuiltInActiveRule::ruleKey).contains("S3649");
+    } finally {
+      PythonRules.getRuleKeys().clear();
+    }
+  }
+
+  @Test
+  void should_contain_dataflow_bug_detection_rules_when_available() {
+    com.sonarsource.plugins.dbd.api.PythonRules.getDataflowBugDetectionRuleKeys().add("S2259");
+    try {
+      BuiltInQualityProfilesDefinition.BuiltInQualityProfile profile = getProfile();
+      assertThat(profile.rules()).extracting("repoKey").contains("dbd-repo-key");
+      assertThat(profile.rules()).extracting(BuiltInActiveRule::ruleKey).contains("S2259");
+    } finally {
+      com.sonarsource.plugins.dbd.api.PythonRules.getDataflowBugDetectionRuleKeys().clear();
+    }
+  }
+
+  @Test
+  void should_contain_architecture_rules_when_available() {
+    ArchitecturePythonRules.getRuleKeys().add("S7134");
+    try {
+      BuiltInQualityProfilesDefinition.BuiltInQualityProfile profile = getProfile();
+      assertThat(profile.rules()).extracting("repoKey").contains("pythonarchitecture");
+      assertThat(profile.rules()).extracting(BuiltInActiveRule::ruleKey).contains("S7134");
+    } finally {
+      ArchitecturePythonRules.getRuleKeys().clear();
+    }
+  }
+}
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/AbstractPythonRuleRepositoryTest.java b/python-commons/src/test/java/org/sonar/plugins/python/AbstractPythonRuleRepositoryTest.java
index 66dc8d8ba9..093c27cc3d 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/AbstractPythonRuleRepositoryTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/AbstractPythonRuleRepositoryTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,7 @@
  */
 package org.sonar.plugins.python;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.util.List;
 import java.util.Set;
 import org.junit.jupiter.api.Test;
@@ -23,7 +24,6 @@
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.SonarRuntime;
 import org.sonar.api.batch.rule.CheckFactory;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.server.rule.RulesDefinition;
 import org.sonar.api.utils.Version;
 import org.sonar.check.Rule;
@@ -85,7 +85,7 @@ private static class DummyNoSonarCheck extends PythonChecks {
   }
 
   private RulesDefinition.Repository createDummy(List> checks, Set templateRuleKeys, Set disabledRuleKeys) {
-    var runtime = SonarRuntimeImpl.forSonarQube(Version.create(9, 3), SonarQubeSide.SERVER, SonarEdition.COMMUNITY);
+    var runtime = TestSonarRuntime.forSonarQube(Version.create(9, 3), SonarQubeSide.SERVER, SonarEdition.COMMUNITY);
     var dummyRepo = new DummyRuleRepository(runtime) {
       @Override
       protected List> getCheckClasses() {
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/DependencyTelemetrySensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/DependencyTelemetrySensorTest.java
index 906a8e45d7..54b57a348a 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/DependencyTelemetrySensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/DependencyTelemetrySensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,8 +18,8 @@
 
 import java.nio.file.Paths;
 import org.junit.jupiter.api.Test;
-import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import org.sonar.scanner.plugin.api.impl.sensor.DefaultSensorDescriptor;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
 import org.sonar.plugins.python.telemetry.TelemetryMetricKey;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/GeneratedIPythonFileTest.java b/python-commons/src/test/java/org/sonar/plugins/python/GeneratedIPythonFileTest.java
index 9ce2410bad..d529f5f0eb 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/GeneratedIPythonFileTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/GeneratedIPythonFileTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,7 +20,7 @@
 import java.util.Map;
 import org.junit.jupiter.api.Test;
 import org.sonar.api.batch.fs.InputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
 import org.sonar.plugins.python.PythonInputFile.Kind;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/IPynbAIQualityProfileTest.java b/python-commons/src/test/java/org/sonar/plugins/python/IPynbAIQualityProfileTest.java
new file mode 100644
index 0000000000..ea58a316de
--- /dev/null
+++ b/python-commons/src/test/java/org/sonar/plugins/python/IPynbAIQualityProfileTest.java
@@ -0,0 +1,46 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.api.server.profile.BuiltInQualityProfilesDefinition;
+import org.sonar.api.server.profile.BuiltInQualityProfilesDefinition.BuiltInActiveRule;
+import org.sonar.plugins.python.editions.OpenSourceRepositoryInfoProvider;
+import org.sonar.plugins.python.editions.RepositoryInfoProvider;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class IPynbAIQualityProfileTest {
+
+  public BuiltInQualityProfilesDefinition.BuiltInQualityProfile getProfile() {
+    BuiltInQualityProfilesDefinition.Context context = new BuiltInQualityProfilesDefinition.Context();
+    new IPynbAIQualityProfile(new RepositoryInfoProvider[]{new OpenSourceRepositoryInfoProvider()}).define(context);
+    return context.profile("ipynb", "Sonar agentic AI");
+  }
+
+  @Test
+  void profile() {
+    BuiltInQualityProfilesDefinition.BuiltInQualityProfile profile = getProfile();
+    assertThat(profile.rules()).extracting("repoKey").containsOnly("ipython");
+    assertThat(profile.rules()).hasSizeGreaterThan(25);
+    assertThat(profile.rules()).extracting(BuiltInActiveRule::ruleKey).contains("S100");
+    // Rules disabled for notebooks should be excluded
+    assertThat(profile.rules()).extracting(BuiltInActiveRule::ruleKey).doesNotContain("S905");
+    assertThat(profile.rules()).extracting(BuiltInActiveRule::ruleKey).doesNotContain("S2201");
+    assertThat(profile.rules()).extracting(BuiltInActiveRule::ruleKey).doesNotContain("S1481");
+  }
+}
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/IPynbProfileTest.java b/python-commons/src/test/java/org/sonar/plugins/python/IPynbProfileTest.java
index 6161e18d7d..ec16c53333 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/IPynbProfileTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/IPynbProfileTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/IPynbRuleRepositoryTest.java b/python-commons/src/test/java/org/sonar/plugins/python/IPynbRuleRepositoryTest.java
index 31440111ef..8c266b90ea 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/IPynbRuleRepositoryTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/IPynbRuleRepositoryTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,7 @@
  */
 package org.sonar.plugins.python;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
@@ -24,7 +25,6 @@
 import org.sonar.api.SonarEdition;
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.SonarRuntime;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.server.rule.RulesDefinition;
 import org.sonar.api.utils.Version;
 
@@ -76,7 +76,7 @@ private static RulesDefinition.Repository buildRepository() {
   }
 
   private static RulesDefinition.Repository buildRepository(int majorVersion, int minorVersion) {
-    SonarRuntime sonarRuntime = SonarRuntimeImpl.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER);
+    SonarRuntime sonarRuntime = TestSonarRuntime.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER);
     IPynbRuleRepository ruleRepository = new IPynbRuleRepository(sonarRuntime);
     RulesDefinition.Context context = new RulesDefinition.Context();
     ruleRepository.define(context);
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/IPynbSensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/IPynbSensorTest.java
index 4ddd69f69a..e477d019b2 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/IPynbSensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/IPynbSensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,9 @@
  */
 package org.sonar.plugins.python;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
@@ -24,20 +27,11 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
-import org.mockito.Mockito;
 import org.slf4j.event.Level;
 import org.sonar.api.SonarRuntime;
 import org.sonar.api.batch.fs.InputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.rule.ActiveRules;
 import org.sonar.api.batch.rule.CheckFactory;
-import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
-import org.sonar.api.batch.rule.internal.NewActiveRule;
-import org.sonar.api.batch.sensor.cpd.internal.TokensLine;
-import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
-import org.sonar.api.config.internal.MapSettings;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.issue.NoSonarFilter;
 import org.sonar.api.measures.CoreMetrics;
 import org.sonar.api.measures.FileLinesContext;
@@ -45,6 +39,7 @@
 import org.sonar.api.rule.RuleKey;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.api.utils.Version;
+import org.sonar.duplications.internal.pmd.TokensLine;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonVersionUtils;
 import org.sonar.plugins.python.editions.OpenSourceRepositoryInfoProvider;
@@ -55,11 +50,16 @@
 import org.sonar.plugins.python.nosonar.NoSonarLineInfoCollector;
 import org.sonar.plugins.python.telemetry.TelemetryMetricKey;
 import org.sonar.python.project.config.ProjectConfigurationBuilder;
+import org.sonar.scanner.plugin.api.impl.config.MapSettings;
+import org.sonar.scanner.plugin.api.impl.rule.ActiveRulesBuilder;
+import org.sonar.scanner.plugin.api.impl.rule.NewActiveRule;
+import org.sonar.scanner.plugin.api.impl.sensor.DefaultSensorDescriptor;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
@@ -72,7 +72,7 @@ class IPynbSensorTest {
 
   private static final Version SONARLINT_DETECTABLE_VERSION = Version.create(9, 9);
 
-  static final SonarRuntime SONARLINT_RUNTIME = SonarRuntimeImpl.forSonarLint(SONARLINT_DETECTABLE_VERSION);
+  static final SonarRuntime SONARLINT_RUNTIME = TestSonarRuntime.forSonarLint(SONARLINT_DETECTABLE_VERSION);
 
   private static final String FILE_1 = "file1.ipynb";
   private static final String NOTEBOOK_FILE = "notebook.ipynb";
@@ -137,7 +137,7 @@ private IPynbSensor sensor() {
   private IPynbSensor sensor(PythonIndexer indexer) {
     FileLinesContextFactory fileLinesContextFactory = mock(FileLinesContextFactory.class);
     FileLinesContext fileLinesContext = mock(FileLinesContext.class);
-    when(fileLinesContextFactory.createFor(Mockito.any(InputFile.class))).thenReturn(fileLinesContext);
+    when(fileLinesContextFactory.createFor(any(InputFile.class))).thenReturn(fileLinesContext);
     CheckFactory checkFactory = new CheckFactory(activeRules);
     return new IPynbSensor(fileLinesContextFactory,
       checkFactory,
@@ -183,10 +183,39 @@ void test_python_version_parameter() {
     assertThat(ProjectPythonVersion.currentVersions()).containsExactly(PythonVersionUtils.MAX_SUPPORTED_VERSION);
   }
 
+  @Test
+  void test_python_version_range_parameter() {
+    context.setRuntime(SONARLINT_RUNTIME);
+
+    PythonInputFile inputFile = inputFile(FILE_1);
+    activeRules = new ActiveRulesBuilder().build();
+    context.setSettings(new MapSettings().setProperty("sonar.python.version", ">=3.10,<3.12"));
+    PythonIndexer pythonIndexer = pythonIndexer(List.of(inputFile));
+
+    sensor(pythonIndexer).execute(context);
+
+    assertThat(ProjectPythonVersion.currentVersions()).containsExactly(
+      PythonVersionUtils.Version.V_310,
+      PythonVersionUtils.Version.V_311);
+  }
+
+  @Test
+  void absent_python_version_resets_current_versions() {
+    context.setRuntime(SONARLINT_RUNTIME);
+    PythonInputFile inputFile = inputFile(FILE_1);
+    activeRules = new ActiveRulesBuilder().build();
+    PythonIndexer pythonIndexer = pythonIndexer(List.of(inputFile));
+    ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.fromString("3.10"));
+
+    sensor(pythonIndexer).execute(context);
+
+    assertThat(ProjectPythonVersion.currentVersions()).containsExactlyElementsOf(PythonVersionUtils.allVersions());
+  }
+
   private IPynbSensor notebookSensor() {
     FileLinesContextFactory fileLinesContextFactory = mock(FileLinesContextFactory.class);
     FileLinesContext fileLinesContext = mock(FileLinesContext.class);
-    when(fileLinesContextFactory.createFor(Mockito.any(InputFile.class))).thenReturn(fileLinesContext);
+    when(fileLinesContextFactory.createFor(any(InputFile.class))).thenReturn(fileLinesContext);
     CheckFactory checkFactory = new CheckFactory(activeRules);
     return new IPynbSensor(fileLinesContextFactory,
       checkFactory,
@@ -236,11 +265,11 @@ void test_notebook_sensor_is_executed_on_json_file() {
     var sensor = spy(notebookSensor());
     var contextSpy = spy(context);
     assertDoesNotThrow(() -> sensor.execute(contextSpy));
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_PRESENT_KEY.key(), "1");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_RECOGNITION_ERROR_KEY.key(), "0");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_TOTAL_KEY.key(), "1");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_EXCEPTION_KEY.key(), "0");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(eq(TelemetryMetricKey.NOTEBOOKS_ANALYSIS_DURATION_KEY.key()), anyString());
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_PRESENT_KEY.key(), "1");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_RECOGNITION_ERROR_KEY.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_TOTAL_KEY.key(), "1");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_EXCEPTION_KEY.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(eq(TelemetryMetricKey.NOTEBOOKS_ANALYSIS_DURATION_KEY.key()), anyString());
   }
 
   @Test
@@ -262,10 +291,10 @@ void test_notebook_sensor_parse_error_on_valid_line() {
     sensor.execute(contextSpy);
     var logs = String.join("", logTester.logs());
     assertThat(logs).contains("Unable to parse file: notebook_parse_error.ipynbParse error at line 1");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_PRESENT_KEY.key(), "1");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_RECOGNITION_ERROR_KEY.key(), "1");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_TOTAL_KEY.key(), "1");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_EXCEPTION_KEY.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_PRESENT_KEY.key(), "1");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_RECOGNITION_ERROR_KEY.key(), "1");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_TOTAL_KEY.key(), "1");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.NOTEBOOK_EXCEPTION_KEY.key(), "0");
   }
 
   @Test
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/IPynbTest.java b/python-commons/src/test/java/org/sonar/plugins/python/IPynbTest.java
index 0ec2165008..fc7117d153 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/IPynbTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/IPynbTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,8 +17,8 @@
 package org.sonar.plugins.python;
 
 import org.junit.jupiter.api.Test;
-import org.sonar.api.config.internal.ConfigurationBridge;
-import org.sonar.api.config.internal.MapSettings;
+import org.sonar.scanner.plugin.api.impl.config.ConfigurationBridge;
+import org.sonar.scanner.plugin.api.impl.config.MapSettings;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/IpynbNotebookParserScannerTest.java b/python-commons/src/test/java/org/sonar/plugins/python/IpynbNotebookParserScannerTest.java
index 2c32114cbd..ab6400b196 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/IpynbNotebookParserScannerTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/IpynbNotebookParserScannerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,6 +18,7 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.util.Map;
 import org.junit.jupiter.api.Test;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.plugins.python.api.IssueLocation;
@@ -32,6 +33,19 @@ class IpynbNotebookParserScannerTest {
 
   private final File baseDir = new File("src/test/resources/org/sonar/plugins/python");
 
+  @Test
+  void generated_notebook_python_uses_the_test_file_classifier() {
+    var inputFile = createInputFile(baseDir, "notebook_trailing_whitespace.ipynb", InputFile.Status.CHANGED, InputFile.Type.MAIN);
+    var notebook = IpynbNotebookParser.parseNotebook(inputFile).get();
+    var generatedFile = new GeneratedIPythonFile(notebook.wrappedFile(), "import pytest\n", Map.of());
+    var context = new PythonVisitorContext.Builder(
+      TestPythonVisitorRunner.parseNotebookFile(Map.of(), "import pytest\n"),
+      SonarQubePythonFile.create(generatedFile))
+      .build();
+
+    assertThat(context.isLikelyTestFile()).isTrue();
+  }
+
   @Test
   void trailing_whitespace() throws IOException {
     var inputFile = createInputFile(baseDir, "notebook_trailing_whitespace.ipynb", InputFile.Status.CHANGED, InputFile.Type.MAIN);
@@ -92,4 +106,39 @@ void trailing_whitespace_compressed() throws IOException {
     assertThat(issues.get(2).primaryLocation().endLineOffset()).isEqualTo(249); // Should be 255
   }
 
+  @Test
+  void multiline_string_in_source_array() throws IOException {
+    var inputFile = createInputFile(baseDir, "notebook_multiline_string_in_array.ipynb", InputFile.Status.CHANGED, InputFile.Type.MAIN);
+    var result = IpynbNotebookParser.parseNotebook(inputFile).get();
+
+    // Should not throw IllegalStateException("No IPythonLocation found for line ...")
+    var fileInput = TestPythonVisitorRunner.parseNotebookFile(result.locationMap(), result.contents());
+
+    var statements = fileInput.statements().statements();
+    // Every statement lives on the same raw ipynb line, since the whole array element is one JSON string
+    // spanning a single physical line; columns must still strictly increase to reflect their real position.
+    assertThat(statements)
+      .hasSize(8)
+      .allSatisfy(stmt -> assertThat(stmt.firstToken().line()).isEqualTo(9))
+      .extracting(stmt -> stmt.firstToken().column()).isSorted();
+  }
+
+  @Test
+  void multiline_array_element_without_trailing_newline_continues_next_element() throws IOException {
+    // "source": ["x = 1\ny", " = 2"]: the first element's last split line ("y") has no trailing newline of
+    // its own, so the second element (" = 2") continues it on the same physical line instead of starting
+    // a new one. This used to add one locationMap entry too many, misaligning every line after it.
+    var inputFile = createInputFile(baseDir, "notebook_multiline_string_in_array_no_trailing_newline.ipynb", InputFile.Status.CHANGED, InputFile.Type.MAIN);
+    var result = IpynbNotebookParser.parseNotebook(inputFile).get();
+
+    var fileInput = TestPythonVisitorRunner.parseNotebookFile(result.locationMap(), result.contents());
+
+    var statements = fileInput.statements().statements();
+    assertThat(statements).hasSize(2);
+    assertThat(statements.get(0).firstToken().line()).isEqualTo(9);
+    assertThat(statements.get(1).firstToken().line()).isEqualTo(9);
+    // "y = 2" starts further along the raw ipynb line than "x = 1"
+    assertThat(statements.get(1).firstToken().column()).isGreaterThan(statements.get(0).firstToken().column());
+  }
+
 }
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/IssuesRepositoryTest.java b/python-commons/src/test/java/org/sonar/plugins/python/IssuesRepositoryTest.java
new file mode 100644
index 0000000000..b4594ecbc8
--- /dev/null
+++ b/python-commons/src/test/java/org/sonar/plugins/python/IssuesRepositoryTest.java
@@ -0,0 +1,167 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python;
+
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.List;
+import java.util.concurrent.locks.ReentrantLock;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.sonar.api.batch.fs.InputFile;
+import org.sonar.api.batch.sensor.issue.Issue;
+import org.sonar.api.batch.sensor.issue.NewIssue;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.plugins.python.api.IssueLocation;
+import org.sonar.plugins.python.api.LocationInFile;
+import org.sonar.plugins.python.api.PythonCheck;
+import org.sonar.plugins.python.api.PythonVisitorCheck;
+import org.sonar.plugins.python.indexer.PythonIndexer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+class IssuesRepositoryTest {
+
+  @TempDir
+  File baseDir;
+
+  private SensorContextTester context;
+  private PythonInputFile inputFile;
+
+  @BeforeEach
+  void setUp() throws Exception {
+    File source = new File(baseDir, "sample.py");
+    Files.writeString(source.toPath(), "x = 1\ny = 2\n");
+    context = SensorContextTester.create(baseDir);
+    inputFile = new PythonInputFileImpl(TestInputFileBuilder.create("moduleKey", "sample.py")
+      .setModuleBaseDir(baseDir.toPath())
+      .setCharset(StandardCharsets.UTF_8)
+      .setLanguage(Python.KEY)
+      .setType(InputFile.Type.MAIN)
+      .initMetadata(TestUtils.fileContent(source, StandardCharsets.UTF_8))
+      .build());
+    context.fileSystem().add(inputFile.wrappedFile());
+  }
+
+  @Test
+  void reports_typed_data_flows_with_description() {
+    context = spy(context);
+    MockSonarLintIssue mockIssue = new MockSonarLintIssue(context);
+    when(context.newIssue()).thenReturn(mockIssue);
+
+    PythonChecks checks = mock(PythonChecks.class);
+    when(checks.ruleKey(any())).thenReturn(RuleKey.of("python", "S9999"));
+    PythonIndexer indexer = mock(PythonIndexer.class);
+
+    PythonCheck check = new PythonVisitorCheck() {
+    };
+    PythonCheck.PreciseIssue preciseIssue = new PythonCheck.PreciseIssue(check,
+      IssueLocation.preciseLocation(new LocationInFile(null, 1, 0, 1, 1), "primary"));
+    preciseIssue.addFlow("Actual value first",
+      List.of(IssueLocation.preciseLocation(new LocationInFile(null, 1, 0, 1, 1), "Actual value first.")));
+    preciseIssue.addFlow("Expected value first",
+      List.of(IssueLocation.preciseLocation(new LocationInFile(null, 2, 0, 2, 1), "Expected value first.")));
+
+    IssuesRepository repository = new IssuesRepository(context, checks, indexer, true, new ReentrantLock());
+    repository.save(inputFile, List.of(preciseIssue));
+
+    assertThat(mockIssue.getSaved()).isTrue();
+    assertThat(mockIssue.flows()).hasSize(2);
+    Issue.Flow firstFlow = mockIssue.flows().get(0);
+    assertThat(firstFlow.type()).isEqualTo(NewIssue.FlowType.DATA);
+    assertThat(firstFlow.description()).isEqualTo("Actual value first");
+    assertThat(firstFlow.locations()).hasSize(1);
+    assertThat(firstFlow.locations().get(0).message()).isEqualTo("Actual value first.");
+
+    Issue.Flow secondFlow = mockIssue.flows().get(1);
+    assertThat(secondFlow.type()).isEqualTo(NewIssue.FlowType.DATA);
+    assertThat(secondFlow.description()).isEqualTo("Expected value first");
+  }
+
+  @Test
+  void reports_flow_locations_from_other_files() throws Exception {
+    File otherSource = new File(baseDir, "other.py");
+    Files.writeString(otherSource.toPath(), "z = 3\n");
+    PythonInputFile otherFile = new PythonInputFileImpl(TestInputFileBuilder.create("moduleKey", "other.py")
+      .setModuleBaseDir(baseDir.toPath())
+      .setCharset(StandardCharsets.UTF_8)
+      .setLanguage(Python.KEY)
+      .setType(InputFile.Type.MAIN)
+      .initMetadata(TestUtils.fileContent(otherSource, StandardCharsets.UTF_8))
+      .build());
+    context.fileSystem().add(otherFile.wrappedFile());
+
+    context = spy(context);
+    MockSonarLintIssue mockIssue = new MockSonarLintIssue(context);
+    when(context.newIssue()).thenReturn(mockIssue);
+
+    PythonChecks checks = mock(PythonChecks.class);
+    when(checks.ruleKey(any())).thenReturn(RuleKey.of("python", "S9999"));
+    PythonIndexer indexer = mock(PythonIndexer.class);
+
+    PythonCheck check = new PythonVisitorCheck() {
+    };
+    PythonCheck.PreciseIssue preciseIssue = new PythonCheck.PreciseIssue(check,
+      IssueLocation.preciseLocation(new LocationInFile(null, 1, 0, 1, 1), "primary"));
+    preciseIssue.addFlow("Cross-file flow",
+      List.of(IssueLocation.preciseLocation(
+        new LocationInFile(otherSource.getAbsolutePath(), 1, 0, 1, 1),
+        "On other file")));
+
+    IssuesRepository repository = new IssuesRepository(context, checks, indexer, true, new ReentrantLock());
+    repository.save(inputFile, List.of(preciseIssue));
+
+    assertThat(mockIssue.getSaved()).isTrue();
+    assertThat(mockIssue.flows()).hasSize(1);
+    assertThat(mockIssue.flows().get(0).description()).isEqualTo("Cross-file flow");
+    assertThat(mockIssue.flows().get(0).locations()).hasSize(1);
+  }
+
+  @Test
+  void skips_flow_locations_when_file_cannot_be_resolved() {
+    context = spy(context);
+    MockSonarLintIssue mockIssue = new MockSonarLintIssue(context);
+    when(context.newIssue()).thenReturn(mockIssue);
+
+    PythonChecks checks = mock(PythonChecks.class);
+    when(checks.ruleKey(any())).thenReturn(RuleKey.of("python", "S9999"));
+    PythonIndexer indexer = mock(PythonIndexer.class);
+
+    PythonCheck check = new PythonVisitorCheck() {
+    };
+    PythonCheck.PreciseIssue preciseIssue = new PythonCheck.PreciseIssue(check,
+      IssueLocation.preciseLocation(new LocationInFile(null, 1, 0, 1, 1), "primary"));
+    preciseIssue.addFlow("Unresolved flow",
+      List.of(IssueLocation.preciseLocation(
+        new LocationInFile("/does/not/exist.py", 1, 0, 1, 1),
+        "Missing file")));
+
+    IssuesRepository repository = new IssuesRepository(context, checks, indexer, true, new ReentrantLock());
+    repository.save(inputFile, List.of(preciseIssue));
+
+    assertThat(mockIssue.getSaved()).isTrue();
+    assertThat(mockIssue.flows()).isEmpty();
+  }
+}
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/MeasuresRepositoryTest.java b/python-commons/src/test/java/org/sonar/plugins/python/MeasuresRepositoryTest.java
index ff7bef9da0..a1d02f6282 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/MeasuresRepositoryTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/MeasuresRepositoryTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/MockSonarLintIssue.java b/python-commons/src/test/java/org/sonar/plugins/python/MockSonarLintIssue.java
index 65fb02c2fb..32b7001209 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/MockSonarLintIssue.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/MockSonarLintIssue.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,13 +16,14 @@
  */
 package org.sonar.plugins.python;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.StreamSupport;
 import javax.annotation.Nullable;
 import org.sonar.api.batch.rule.Severity;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
 import org.sonar.api.batch.sensor.issue.Issue;
 import org.sonar.api.batch.sensor.issue.IssueLocation;
 import org.sonar.api.batch.sensor.issue.NewIssue;
@@ -40,7 +41,9 @@ class MockSonarLintIssue implements NewIssue, Issue {
   private boolean isQuickFixAvailable = false;
   @Nullable
   private List codeVariants = null;
+  private List internalTags = List.of();
   private boolean saved;
+  private final List flows = new ArrayList<>();
 
   MockSonarLintIssue(SensorContextTester context) {
     this.context = context;
@@ -97,12 +100,39 @@ public NewIssue setQuickFixAvailable(boolean b) {
 
   @Override
   public NewIssue addFlow(Iterable flowLocations) {
-    throw new IllegalStateException("Not supposed to be tested");
+    return addFlow(flowLocations, FlowType.UNDEFINED, null);
+  }
+
+  @Override
+  public NewIssue addFlow(Iterable iterable, FlowType flowType, @Nullable String description) {
+    List locations = new ArrayList<>();
+    for (NewIssueLocation newIssueLocation : iterable) {
+      locations.add((IssueLocation) newIssueLocation);
+    }
+    flows.add(new RecordedFlow(locations, flowType, description));
+    return this;
+  }
+
+  @Override
+  public NewIssue setInternalTags(java.util.Collection internalTags) {
+    this.internalTags = List.copyOf(internalTags);
+    return this;
+  }
+
+  @Override
+  public NewIssue addInternalTag(String internalTag) {
+    var tags = new java.util.ArrayList<>(internalTags);
+    tags.add(internalTag);
+    internalTags = List.copyOf(tags);
+    return this;
   }
 
   @Override
-  public NewIssue addFlow(Iterable iterable, FlowType flowType, @Nullable String s) {
-    return null;
+  public NewIssue addInternalTags(java.util.Collection internalTags) {
+    var tags = new java.util.ArrayList<>(this.internalTags);
+    tags.addAll(internalTags);
+    this.internalTags = List.copyOf(tags);
+    return this;
   }
 
   @Override
@@ -144,7 +174,7 @@ public IssueLocation primaryLocation() {
 
   @Override
   public List flows() {
-    throw new IllegalStateException("Not supposed to be tested");
+    return flows;
   }
 
   @Override
@@ -168,6 +198,11 @@ public List codeVariants() {
     return codeVariants;
   }
 
+  @Override
+  public List internalTags() {
+    return internalTags;
+  }
+
   @Override
   public NewIssue setRuleDescriptionContextKey(String ruleDescriptionContextKey) {
     return this;
@@ -183,4 +218,7 @@ public NewIssue setCodeVariants(@Nullable Iterable iterable) {
   public boolean getSaved() {
     return saved;
   }
+
+  private record RecordedFlow(List locations, FlowType type, @Nullable String description) implements Flow {
+  }
 }
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/MultiFileProgressReportTest.java b/python-commons/src/test/java/org/sonar/plugins/python/MultiFileProgressReportTest.java
index a18dd5ae02..5900d7f86f 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/MultiFileProgressReportTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/MultiFileProgressReportTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -36,7 +36,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.atIndex;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.fail;
 
 class MultiFileProgressReportTest {
 
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/NewSymbolsCollectorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/NewSymbolsCollectorTest.java
index c72625c80b..49a9f10282 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/NewSymbolsCollectorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/NewSymbolsCollectorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -23,11 +23,11 @@
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.sonar.api.batch.fs.TextRange;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
-import org.sonar.api.batch.fs.internal.DefaultTextPointer;
-import org.sonar.api.batch.fs.internal.DefaultTextRange;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultInputFile;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultTextPointer;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultTextRange;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
 import org.sonar.python.TestPythonVisitorRunner;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/NotebookParsingDataTest.java b/python-commons/src/test/java/org/sonar/plugins/python/NotebookParsingDataTest.java
index 61a85e156d..f0d2061bf0 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/NotebookParsingDataTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/NotebookParsingDataTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,8 +22,8 @@
 import org.sonar.python.IPythonLocation;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 
 class NotebookParsingDataTest {
   @Test
@@ -100,7 +100,7 @@ void testRemoveTrailingExtraLine() {
   void testEquals() {
     var empty = NotebookParsingData.empty();
     assertEquals(empty, empty);
-    assertNotEquals(empty, "test");
+    assertNotEquals("test", empty);
 
     var data = new NotebookParsingData(new StringBuilder().append("Test"), Map.of(), 0);
     assertNotEquals(data, empty);
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/PythonExtensionsTest.java b/python-commons/src/test/java/org/sonar/plugins/python/PythonExtensionsTest.java
index af6e7963f1..c245722db5 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/PythonExtensionsTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/PythonExtensionsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,7 @@
  */
 package org.sonar.plugins.python;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.util.List;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
@@ -24,7 +25,6 @@
 import org.sonar.api.SonarEdition;
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.SonarRuntime;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.api.utils.Version;
 import org.sonar.plugins.python.api.SonarLintCache;
@@ -42,11 +42,11 @@ class PythonExtensionsTest {
   @Test
   void testGetExtensions() {
     Version v79 = Version.create(7, 9);
-    SonarRuntime runtime = SonarRuntimeImpl.forSonarQube(v79, SonarQubeSide.SERVER, SonarEdition.DEVELOPER);
-    assertThat(extensions(runtime)).hasSize(43);
+    SonarRuntime runtime = TestSonarRuntime.forSonarQube(v79, SonarQubeSide.SERVER, SonarEdition.DEVELOPER);
+    assertThat(extensions(runtime)).hasSize(46);
     assertThat(extensions(runtime)).contains(AnalysisWarningsWrapper.class);
-    assertThat(extensions(SonarRuntimeImpl.forSonarLint(v79)))
-      .hasSize(23)
+    assertThat(extensions(TestSonarRuntime.forSonarLint(v79)))
+      .hasSize(26)
       .contains(SonarLintCache.class);
   }
 
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/PythonHighlighterTest.java b/python-commons/src/test/java/org/sonar/plugins/python/PythonHighlighterTest.java
index 522047e3e2..31b120a94f 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/PythonHighlighterTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/PythonHighlighterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -23,10 +23,10 @@
 import javax.annotation.Nullable;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultInputFile;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
 import org.sonar.api.batch.sensor.highlighting.TypeOfText;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
 import org.sonar.python.IPythonLocation;
 import org.sonar.python.TestPythonVisitorRunner;
 import org.sonar.python.caching.CacheContextImpl;
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/PythonProfileTest.java b/python-commons/src/test/java/org/sonar/plugins/python/PythonProfileTest.java
index 24ff13b07f..6d43ad2d08 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/PythonProfileTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/PythonProfileTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/PythonRuleRepositoryTest.java b/python-commons/src/test/java/org/sonar/plugins/python/PythonRuleRepositoryTest.java
index 8a3800e3ec..b9ac4931ee 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/PythonRuleRepositoryTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/PythonRuleRepositoryTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,7 @@
  */
 package org.sonar.plugins.python;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
@@ -24,7 +25,6 @@
 import org.sonar.api.SonarEdition;
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.SonarRuntime;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.rules.RuleType;
 import org.sonar.api.server.rule.RulesDefinition;
 import org.sonar.api.utils.Version;
@@ -62,27 +62,14 @@ void createRulesTest() throws IOException {
   @Test
   void owaspSecurityStandard() {
     RulesDefinition.Repository repository_9_3 = buildRepository(9, 3);
-    RulesDefinition.Rule s4721_9_3 = repository_9_3.rule("S4721");
-    assertThat(s4721_9_3).isNotNull();
-    assertThat(s4721_9_3.securityStandards()).contains("owaspTop10-2021:a3");
+    RulesDefinition.Rule s2077_9_3 = repository_9_3.rule("S2077");
+    assertThat(s2077_9_3).isNotNull();
+    assertThat(s2077_9_3.securityStandards()).contains("owaspTop10-2021:a3");
 
     RulesDefinition.Repository repository_9_2 = buildRepository(9, 2);
-    RulesDefinition.Rule s4721_9_2 = repository_9_2.rule("S4721");
-    assertThat(s4721_9_2).isNotNull();
-    assertThat(s4721_9_2.securityStandards()).doesNotContain("owaspTop10-2021:a3");
-  }
-
-  @Test
-  void psiDssSecurityStandard() {
-    RulesDefinition.Repository repository_9_5 = buildRepository(9, 5);
-    RulesDefinition.Rule s4792_9_5 = repository_9_5.rule("S4792");
-    assertThat(s4792_9_5).isNotNull();
-    assertThat(s4792_9_5.securityStandards()).contains("pciDss-3.2:10.1", "pciDss-3.2:10.2", "pciDss-3.2:10.3", "pciDss-4.0:10.2");
-
-    RulesDefinition.Repository repository_9_4 = buildRepository(9, 4);
-    RulesDefinition.Rule s4792_9_4 = repository_9_4.rule("S4792");
-    assertThat(s4792_9_4).isNotNull();
-    assertThat(s4792_9_4.securityStandards()).doesNotContain("pciDss-3.2:10.1", "pciDss-3.2:10.2", "pciDss-3.2:10.3", "pciDss-4.0:10.2");
+    RulesDefinition.Rule s2077_9_2 = repository_9_2.rule("S2077");
+    assertThat(s2077_9_2).isNotNull();
+    assertThat(s2077_9_2.securityStandards()).doesNotContain("owaspTop10-2021:a3");
   }
 
   private List nonAbstractCheckFiles() throws IOException {
@@ -118,10 +105,10 @@ void ruleTemplates() {
   }
 
   @Test
-  void hotspotRules() {
+  void convertedHotspotRules() {
     RulesDefinition.Repository repository = buildRepository();
-    RulesDefinition.Rule hardcodedIp = repository.rule("S1313");
-    assertThat(hardcodedIp.type()).isEqualTo(RuleType.SECURITY_HOTSPOT);
+    RulesDefinition.Rule sqlInjection = repository.rule("S2077");
+    assertThat(sqlInjection.type()).isEqualTo(RuleType.VULNERABILITY);
   }
 
   private static RulesDefinition.Repository buildRepository() {
@@ -129,7 +116,7 @@ private static RulesDefinition.Repository buildRepository() {
   }
 
   private static RulesDefinition.Repository buildRepository(int majorVersion, int minorVersion) {
-    SonarRuntime sonarRuntime = SonarRuntimeImpl.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER);
+    SonarRuntime sonarRuntime = TestSonarRuntime.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER);
     PythonRuleRepository ruleRepository = new PythonRuleRepository(sonarRuntime);
     RulesDefinition.Context context = new RulesDefinition.Context();
     ruleRepository.define(context);
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/PythonSensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/PythonSensorTest.java
index 771f0d26ef..4a7fda3761 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/PythonSensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/PythonSensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,9 @@
  */
 package org.sonar.plugins.python;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
@@ -38,36 +41,25 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
 import org.junit.jupiter.params.provider.ValueSource;
-import org.mockito.Mockito;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.event.Level;
 import org.sonar.api.SonarProduct;
 import org.sonar.api.SonarRuntime;
-import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.InputFile.Type;
+import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.TextPointer;
 import org.sonar.api.batch.fs.TextRange;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
-import org.sonar.api.batch.fs.internal.DefaultTextPointer;
-import org.sonar.api.batch.fs.internal.DefaultTextRange;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.rule.ActiveRules;
 import org.sonar.api.batch.rule.CheckFactory;
-import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
-import org.sonar.api.batch.rule.internal.NewActiveRule;
-import org.sonar.api.batch.sensor.cpd.internal.TokensLine;
 import org.sonar.api.batch.sensor.error.AnalysisError;
-import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
 import org.sonar.api.batch.sensor.issue.Issue;
 import org.sonar.api.batch.sensor.issue.IssueLocation;
 import org.sonar.api.batch.sensor.issue.fix.NewQuickFix;
 import org.sonar.api.batch.sensor.issue.fix.QuickFix;
 import org.sonar.api.batch.sensor.issue.fix.TextEdit;
-import org.sonar.api.config.internal.MapSettings;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.issue.NoSonarFilter;
 import org.sonar.api.measures.CoreMetrics;
 import org.sonar.api.measures.FileLinesContext;
@@ -77,6 +69,7 @@
 import org.sonar.api.utils.Version;
 import org.sonar.check.Rule;
 import org.sonar.check.RuleProperty;
+import org.sonar.duplications.internal.pmd.TokensLine;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
 import org.sonar.plugins.python.api.PythonCheck;
 import org.sonar.plugins.python.api.PythonCustomRuleRepository;
@@ -108,6 +101,13 @@
 import org.sonar.python.project.config.ProjectConfigurationBuilder;
 import org.sonar.python.tree.TokenImpl;
 import org.sonar.python.types.TypeShed;
+import org.sonar.scanner.plugin.api.impl.config.MapSettings;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultInputFile;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultTextPointer;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultTextRange;
+import org.sonar.scanner.plugin.api.impl.rule.ActiveRulesBuilder;
+import org.sonar.scanner.plugin.api.impl.rule.NewActiveRule;
+import org.sonar.scanner.plugin.api.impl.sensor.DefaultSensorDescriptor;
 import org.sonarsource.sonarlint.core.analysis.api.ClientInputFile;
 import org.sonarsource.sonarlint.core.analysis.container.analysis.filesystem.FileMetadata;
 import org.sonarsource.sonarlint.core.analysis.container.analysis.filesystem.SonarLintInputFile;
@@ -120,6 +120,7 @@
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -129,7 +130,9 @@
 import static org.sonar.plugins.python.caching.Caching.CPD_TOKENS_STRING_TABLE_KEY_PREFIX;
 import static org.sonar.plugins.python.caching.Caching.IMPORTS_MAP_CACHE_KEY_PREFIX;
 import static org.sonar.plugins.python.caching.Caching.PROJECT_SYMBOL_TABLE_CACHE_KEY_PREFIX;
+import static org.sonar.plugins.python.caching.Caching.TEST_SOURCES_CONFIGURED_KEY;
 import static org.sonar.plugins.python.caching.Caching.TYPESHED_MODULES_KEY;
+import static org.sonar.plugins.python.caching.Caching.effectiveFileTypeCacheKey;
 import static org.sonar.plugins.python.caching.Caching.fileContentHashCacheKey;
 import static org.sonar.plugins.python.caching.Caching.importsMapCacheKey;
 import static org.sonar.plugins.python.caching.Caching.projectSymbolTableCacheKey;
@@ -142,6 +145,7 @@ class PythonSensorTest {
   private static final String FILE_USING_TYPESHED = "uses_typeshed.py";
   private static final String FILE_QUICKFIX = "file_quickfix.py";
   private static final String FILE_TEST_FILE = "test_file.py";
+  private static final String FILE_FRAMEWORK_HELPER = "framework_helper.py";
   private static final String FILE_INVALID_SYNTAX = "invalid_syntax.py";
   private static final String FILE_NO_SONAR_PY = "no_sonar.py";
   private static final String ONE_STATEMENT_PER_LINE_RULE_KEY = "OneStatementPerLine";
@@ -153,7 +157,7 @@ class PythonSensorTest {
 
   private static final Version SONARLINT_DETECTABLE_VERSION = Version.create(6, 0);
 
-  static final SonarRuntime SONARLINT_RUNTIME = SonarRuntimeImpl.forSonarLint(SONARLINT_DETECTABLE_VERSION);
+  static final SonarRuntime SONARLINT_RUNTIME = TestSonarRuntime.forSonarLint(SONARLINT_DETECTABLE_VERSION);
 
   private static final PythonCustomRuleRepository[] CUSTOM_RULES = {new PythonCustomRuleRepository() {
     @Override
@@ -293,7 +297,7 @@ void test_execute_on_sonarlint() {
   @Test
   void test_execute_on_sonarlint_quickfix() throws IOException {
     context.setRuntime(SONARLINT_RUNTIME);
-    context = Mockito.spy(context);
+    context = spy(context);
     when(context.newIssue()).thenReturn(new MockSonarLintIssue(context));
 
     activate_rule_S2710();
@@ -326,7 +330,7 @@ void test_execute_on_sonarlint_quickfix() throws IOException {
   @Test
   void test_execute_on_sonarlint_quickfix_broken() throws IOException {
     context.setRuntime(SONARLINT_RUNTIME);
-    context = Mockito.spy(context);
+    context = spy(context);
     when(context.newIssue()).thenReturn(new MockSonarLintIssue(context) {
       @Override
       public NewQuickFix newQuickFix() {
@@ -610,6 +614,125 @@ void test_issues_on_test_files() {
     assertThat(issue.ruleKey().rule()).isEqualTo("S5905");
   }
 
+  @Test
+  void test_ncloc_metric_on_test_file() {
+    activeRules = new ActiveRulesBuilder().build();
+    PythonInputFile inputFile = inputFile(FILE_TEST_FILE, Type.TEST);
+    sensor().execute(context);
+
+    assertThat(context.measure(inputFile.wrappedFile().key(), CoreMetrics.NCLOC).value()).isEqualTo(3);
+  }
+
+  @Test
+  void test_ncloc_metric_not_saved_on_test_file_in_sonarlint() {
+    context.setRuntime(SONARLINT_RUNTIME);
+    activeRules = new ActiveRulesBuilder().build();
+    PythonInputFile inputFile = inputFile(FILE_TEST_FILE, Type.TEST);
+    sensor().execute(context);
+
+    assertThat(context.measure(inputFile.wrappedFile().key(), CoreMetrics.NCLOC)).isNull();
+  }
+
+  @Test
+  void test_auto_reclassify_filename_heuristic_suppresses_main_rules() {
+    // sonar.tests NOT set: filename test_*.py triggers heuristic → S1226 (MAIN-scoped) must not fire
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S1226"))
+        .build())
+      .build();
+
+    PythonInputFile inputFile = inputFile(FILE_TEST_FILE, Type.MAIN);
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).isEmpty();
+    // Metrics must still be computed as for a MAIN file (not just NCLOC)
+    assertThat(context.measure(inputFile.wrappedFile().key(), CoreMetrics.FUNCTIONS).value()).isEqualTo(1);
+    verify(analysisWarning).addUnique(PythonScanner.UNSET_SONAR_TESTS_WARNING);
+  }
+
+  @Test
+  void test_auto_reclassify_framework_import_suppresses_main_rules() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S1226"))
+        .build())
+      .build();
+
+    inputFile(FILE_FRAMEWORK_HELPER, Type.MAIN);
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).isEmpty();
+    verify(analysisWarning).addUnique(PythonScanner.UNSET_SONAR_TESTS_WARNING);
+  }
+
+  @ParameterizedTest
+  @CsvSource({
+    "sonar.tests,                              tests",
+    "sonar.python.testFileHeuristic.disabled,  true"
+  })
+  void test_auto_reclassify_bypassed_when_test_source_configured(String property, String value) {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S1226"))
+        .build())
+      .build();
+
+    context.setSettings(new MapSettings().setProperty(property.strip(), value.strip()));
+    inputFile(FILE_TEST_FILE, Type.MAIN);
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).hasSize(1);
+    assertThat(context.allIssues().iterator().next().ruleKey().rule()).isEqualTo("S1226");
+    verify(analysisWarning, never()).addUnique(PythonScanner.UNSET_SONAR_TESTS_WARNING);
+  }
+
+  @Test
+  void test_auto_reclassify_not_bypassed_by_blank_sonar_tests() {
+    // sonar.tests set to blank string is treated as "not configured" — heuristic still fires
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S1226"))
+        .build())
+      .build();
+
+    context.setSettings(new MapSettings().setProperty("sonar.tests", ""));
+    inputFile(FILE_TEST_FILE, Type.MAIN);
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).isEmpty();
+    verify(analysisWarning).addUnique(PythonScanner.UNSET_SONAR_TESTS_WARNING);
+  }
+
+  @Test
+  void test_auto_reclassify_path_directory_heuristic() {
+    // File inside a `tests/` directory classified as MAIN → heuristic fires, S1226 suppressed
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S1226"))
+        .build())
+      .build();
+
+    PythonInputFile inputFile = inputFile("tests/test_file.py", Type.MAIN);
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).isEmpty();
+    assertThat(context.measure(inputFile.wrappedFile().key(), CoreMetrics.FUNCTIONS).value()).isEqualTo(1);
+    verify(analysisWarning).addUnique(PythonScanner.UNSET_SONAR_TESTS_WARNING);
+  }
+
+  @Test
+  void test_auto_reclassify_warning_emitted_once_for_multiple_heuristic_files() {
+    activeRules = new ActiveRulesBuilder().build();
+
+    inputFile(FILE_TEST_FILE, Type.MAIN);
+    inputFile("tests/test_file.py", Type.MAIN);
+    sensor().execute(context);
+
+    // warning must be emitted exactly once regardless of how many files match the heuristic
+    verify(analysisWarning, times(1)).addUnique(PythonScanner.UNSET_SONAR_TESTS_WARNING);
+  }
+
   @Test
   void test_failFast_triggered_on_main_files() {
     activeRules = new ActiveRulesBuilder()
@@ -638,6 +761,96 @@ void test_failFast_not_triggered_on_test_files() {
     assertThat(context.allIssues()).isEmpty();
   }
 
+  @Test
+  void test_cases_should_contain_tests_runs_on_test_files() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S2187"))
+        .build())
+      .build();
+
+    context.setSettings(new MapSettings().setProperty("sonar.tests", "tests"));
+    PythonInputFile inputFile = inputFile("empty_test_case.py", Type.TEST);
+
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).hasSize(1);
+    Issue issue = context.allIssues().iterator().next();
+    assertThat(issue.primaryLocation().inputComponent()).isEqualTo(inputFile.wrappedFile());
+    assertThat(issue.ruleKey().rule()).isEqualTo("S2187");
+  }
+
+  @Test
+  void test_cases_should_contain_tests_skips_main_files() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S2187"))
+        .build())
+      .build();
+
+    context.setSettings(new MapSettings().setProperty("sonar.tests", "tests"));
+    inputFile("empty_test_case.py", Type.MAIN);
+
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).isEmpty();
+  }
+
+  @Test
+  void test_cases_should_contain_tests_skips_main_files_named_like_tests_when_sonar_tests_is_configured() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S2187"))
+        .build())
+      .build();
+
+    context.setSettings(new MapSettings().setProperty("sonar.tests", "tests"));
+    inputFile("test_paths_loader.py", Type.MAIN);
+
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).isEmpty();
+    verify(analysisWarning, never()).addUnique(PythonScanner.UNSET_SONAR_TESTS_WARNING);
+  }
+
+  @Test
+  void test_cases_should_contain_tests_runs_on_test_files_named_like_tests_when_sonar_tests_is_configured() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S2187"))
+        .build())
+      .build();
+
+    context.setSettings(new MapSettings().setProperty("sonar.tests", "tests"));
+    PythonInputFile inputFile = inputFile("test_paths_loader.py", Type.TEST);
+
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).hasSize(1);
+    Issue issue = context.allIssues().iterator().next();
+    assertThat(issue.primaryLocation().inputComponent()).isEqualTo(inputFile.wrappedFile());
+    assertThat(issue.ruleKey().rule()).isEqualTo("S2187");
+  }
+
+  @Test
+  void test_cases_should_contain_tests_runs_on_main_files_named_like_tests_when_sonar_tests_is_not_configured() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S2187"))
+        .build())
+      .build();
+
+    PythonInputFile inputFile = inputFile("test_paths_loader.py", Type.MAIN);
+
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).hasSize(1);
+    Issue issue = context.allIssues().iterator().next();
+    assertThat(issue.primaryLocation().inputComponent()).isEqualTo(inputFile.wrappedFile());
+    assertThat(issue.ruleKey().rule()).isEqualTo("S2187");
+    verify(analysisWarning).addUnique(PythonScanner.UNSET_SONAR_TESTS_WARNING);
+  }
+
   @Test
   void test_test_file_highlighting() {
     activeRules = new ActiveRulesBuilder().build();
@@ -766,6 +979,45 @@ void test_python_version_parameter_no_warning() {
     verify(analysisWarning, times(0)).addUnique(PythonSensor.UNSET_VERSION_WARNING);
   }
 
+  @Test
+  void test_python_version_range_parameter() {
+    context.fileSystem().add(inputFile(FILE_1).wrappedFile());
+    activeRules = new ActiveRulesBuilder().build();
+
+    context.setSettings(new MapSettings().setProperty("sonar.python.version", ">=3.10,<3.12"));
+    sensor().execute(context);
+
+    assertThat(ProjectPythonVersion.currentVersions()).containsExactly(
+      PythonVersionUtils.Version.V_310,
+      PythonVersionUtils.Version.V_311);
+    assertThat(logTester.logs(Level.WARN)).doesNotContain(PythonSensor.UNSET_VERSION_WARNING);
+  }
+
+  @Test
+  void absent_python_version_resets_state_from_previous_analysis() throws IOException {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S6794"))
+        .build())
+      .build();
+    inputFile("python-version/type_alias.py");
+    context.setSettings(new MapSettings().setProperty("sonar.python.version", "3.12"));
+
+    sensor().execute(context);
+
+    assertThat(ProjectPythonVersion.currentVersions()).containsExactly(PythonVersionUtils.Version.V_312);
+    assertThat(context.allIssues()).hasSize(1);
+
+    context = SensorContextTester.create(baseDir);
+    context.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
+    inputFile("python-version/type_alias.py");
+
+    sensor().execute(context);
+
+    assertThat(ProjectPythonVersion.currentVersions()).containsExactlyElementsOf(PythonVersionUtils.allVersions());
+    assertThat(context.allIssues()).isEmpty();
+  }
+
   void setup_typing_concise_rule(String pythonVersion) {
     context.fileSystem().add(inputFile("python-version/typing.py").wrappedFile());
 
@@ -957,6 +1209,7 @@ void test_using_cache() throws IOException {
     readCache.put(CPD_TOKENS_CACHE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.data);
     readCache.put(CPD_TOKENS_STRING_TABLE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.stringTable);
     readCache.put(fileContentHashCacheKey(inputFile.wrappedFile().key()), inputFile.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "MAIN".getBytes(UTF_8));
     context.setPreviousCache(readCache);
     context.setNextCache(writeCache);
     context.setCacheEnabled(true);
@@ -966,6 +1219,8 @@ void test_using_cache() throws IOException {
     assertThat(context.allIssues()).isEmpty();
     assertThat(logTester.logs(Level.INFO))
       .contains("The Python analyzer was able to leverage cached data from previous analyses for 1 out of 1 files. These files were not parsed.");
+    assertThat(writeCache.getData())
+      .containsEntry(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "MAIN".getBytes(UTF_8));
   }
 
   @Test
@@ -1061,6 +1316,7 @@ void test_typeshed_stub_cache_information_is_propagated() throws IOException {
     readCache.put(CPD_TOKENS_CACHE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.data);
     readCache.put(CPD_TOKENS_STRING_TABLE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.stringTable);
     readCache.put(fileContentHashCacheKey(inputFile.wrappedFile().key()), inputFile.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "MAIN".getBytes(UTF_8));
 
     context.setPreviousCache(readCache);
     context.setNextCache(writeCache);
@@ -1074,6 +1330,8 @@ void test_typeshed_stub_cache_information_is_propagated() throws IOException {
     byte[] bytes = writeCache.getData().get(TYPESHED_MODULES_KEY);
     Set resolvedTypeshedModules = new HashSet<>(Arrays.asList(new String(bytes, StandardCharsets.UTF_8).split(";")));
     assertThat(resolvedTypeshedModules).containsExactlyInAnyOrder("math");
+    assertThat(writeCache.getData())
+      .containsEntry(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "MAIN".getBytes(UTF_8));
   }
 
   @Test
@@ -1105,6 +1363,77 @@ void test_scan_without_parsing_test_file() {
     assertThat(context.allIssues()).isEmpty();
   }
 
+  @Test
+  void test_scan_without_parsing_uses_cached_effective_file_type() throws IOException {
+    // File whose path doesn't match path-based test heuristics (no test_ prefix, not in tests/)
+    // but was previously classified as TEST via AST (imports pytest + test_ function with assert).
+    // The cached effectiveFileType=TEST must be used during the cache hit so that S1226 (MAIN-scoped) doesn't fire.
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S1226"))
+        .build())
+      .build();
+
+    PythonInputFile inputFile = inputFile("helper_with_tests.py", Type.MAIN, InputFile.Status.SAME);
+    byte[] serializedSymbolTable = toProtobufModuleDescriptor(Set.of(new VariableDescriptor("test_helper", "helper_with_tests.test_helper", null))).toByteArray();
+    TestReadCache readCache = getValidReadCache();
+    CpdSerializer.SerializationResult cpdTokens = CpdSerializer.serialize(Collections.emptyList());
+    readCache.put(fileContentHashCacheKey(inputFile.wrappedFile().key()), inputFile.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(importsMapCacheKey(inputFile.wrappedFile().key()), "pytest".getBytes(StandardCharsets.UTF_8));
+    readCache.put(projectSymbolTableCacheKey(inputFile.wrappedFile().key()), serializedSymbolTable);
+    readCache.put(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "TEST".getBytes(StandardCharsets.UTF_8));
+    readCache.put(CPD_TOKENS_CACHE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.data);
+    readCache.put(CPD_TOKENS_STRING_TABLE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.stringTable);
+    TestWriteCache writeCache = new TestWriteCache();
+    writeCache.bind(readCache);
+
+    context.setPreviousCache(readCache);
+    context.setNextCache(writeCache);
+    context.setCacheEnabled(true);
+    context.setSettings(new MapSettings().setProperty("sonar.python.skipUnchanged", true));
+    sensor().execute(context);
+
+    assertThat(context.allIssues()).isEmpty();
+    assertThat(logTester.logs(Level.INFO))
+      .contains("The Python analyzer was able to leverage cached data from previous analyses for 1 out of 1 files. These files were not parsed.");
+    verify(analysisWarning, never()).addUnique(PythonScanner.UNSET_SONAR_TESTS_WARNING);
+  }
+
+  @Test
+  void test_scan_without_parsing_falls_back_to_full_parse_when_effective_type_missing_from_cache() throws IOException {
+    // If the effective file type is absent from cache (inconsistent state after e.g. a plugin rollback),
+    // scanFileWithoutParsing must return false so the file is fully re-parsed rather than guessing the type.
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S1226"))
+        .build())
+      .build();
+
+    PythonInputFile inputFile = inputFile("helper_with_tests.py", Type.MAIN, InputFile.Status.SAME);
+    byte[] serializedSymbolTable = toProtobufModuleDescriptor(Set.of(new VariableDescriptor("test_helper", "helper_with_tests.test_helper", null))).toByteArray();
+    TestReadCache readCache = getValidReadCache();
+    CpdSerializer.SerializationResult cpdTokens = CpdSerializer.serialize(Collections.emptyList());
+    readCache.put(fileContentHashCacheKey(inputFile.wrappedFile().key()), inputFile.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(importsMapCacheKey(inputFile.wrappedFile().key()), "pytest".getBytes(StandardCharsets.UTF_8));
+    readCache.put(projectSymbolTableCacheKey(inputFile.wrappedFile().key()), serializedSymbolTable);
+    // effectiveFileTypeCacheKey intentionally absent — simulates inconsistent cache state
+    readCache.put(CPD_TOKENS_CACHE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.data);
+    readCache.put(CPD_TOKENS_STRING_TABLE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.stringTable);
+    TestWriteCache writeCache = new TestWriteCache();
+    writeCache.bind(readCache);
+
+    context.setPreviousCache(readCache);
+    context.setNextCache(writeCache);
+    context.setCacheEnabled(true);
+    context.setSettings(new MapSettings().setProperty("sonar.python.skipUnchanged", true));
+    sensor().execute(context);
+
+    // File is fully re-parsed: the AST-based classifier identifies it as a test file and suppresses S1226.
+    assertThat(context.allIssues()).isEmpty();
+    assertThat(logTester.logs(Level.INFO))
+      .contains("The Python analyzer was able to leverage cached data from previous analyses for 0 out of 1 files. These files were not parsed.");
+  }
+
   @Test
   void test_scan_without_parsing_fails_does_not_reexecute_successful_checks() {
     activeRules = new ActiveRulesBuilder()
@@ -1125,6 +1454,7 @@ void test_scan_without_parsing_fails_does_not_reexecute_successful_checks() {
     readCache.put(importsMapCacheKey(inputFile.wrappedFile().key()), String.join(";", Collections.emptyList()).getBytes(StandardCharsets.UTF_8));
     readCache.put(projectSymbolTableCacheKey(inputFile.wrappedFile().key()), serializedSymbolTable);
     readCache.put(fileContentHashCacheKey(inputFile.wrappedFile().key()), inputFile.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "MAIN".getBytes(UTF_8));
     context.setPreviousCache(readCache);
     context.setNextCache(writeCache);
     context.setCacheEnabled(true);
@@ -1157,6 +1487,7 @@ void test_partial_scan_without_parsing() {
     readCache.put(importsMapCacheKey(inputFile2.wrappedFile().key()), String.join(";", List.of("file1.py")).getBytes(StandardCharsets.UTF_8));
     readCache.put(projectSymbolTableCacheKey(inputFile2.wrappedFile().key()), serializedSymbolTable);
     readCache.put(fileContentHashCacheKey(inputFile2.wrappedFile().key()), inputFile2.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(effectiveFileTypeCacheKey(inputFile2.wrappedFile().key()), "MAIN".getBytes(UTF_8));
     context.setPreviousCache(readCache);
     context.setNextCache(writeCache);
     context.setCacheEnabled(true);
@@ -1217,7 +1548,8 @@ void write_cpd_tokens_to_cache() throws IOException {
 
     assertThat(writeCache.getData().keySet()).containsExactlyInAnyOrder(
       "python:cache_version", "python:files", "python:descriptors:moduleKey:pass.py", "python:imports:moduleKey:pass.py",
-      "python:cpd:data:moduleKey:pass.py", "python:cpd:stringTable:moduleKey:pass.py", "python:content_hashes:moduleKey:pass.py", "python:typeshed_modules");
+      "python:cpd:data:moduleKey:pass.py", "python:cpd:stringTable:moduleKey:pass.py", "python:content_hashes:moduleKey:pass.py",
+      "python:typeshed_modules", "python:test_sources_configured", "python:effective_file_type:moduleKey:pass.py");
 
     byte[] tokenData = writeCache.getData().get("python:cpd:data:moduleKey:pass.py");
     byte[] stringTable = writeCache.getData().get("python:cpd:stringTable:moduleKey:pass.py");
@@ -1309,6 +1641,7 @@ void read_cpd_tokens_from_cache() throws IOException {
     readCache.put(importsMapCacheKey(inputFile.wrappedFile().key()), String.join(";", Collections.emptyList()).getBytes(StandardCharsets.UTF_8));
     readCache.put(projectSymbolTableCacheKey(inputFile.wrappedFile().key()), serializedSymbolTable);
     readCache.put(fileContentHashCacheKey(inputFile.wrappedFile().key()), inputFile.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "MAIN".getBytes(UTF_8));
 
     TestWriteCache writeCache = new TestWriteCache();
     writeCache.bind(readCache);
@@ -1385,8 +1718,6 @@ void read_cpd_tokens_from_cache_corrupted_format() throws IOException {
       .build();
 
     PythonInputFile inputFile = inputFile("pass.py", Type.MAIN, InputFile.Status.SAME);
-    var sslrToken = passToken(inputFile.wrappedFile().uri());
-    List tokens = List.of(new TokenImpl(sslrToken));
 
     TestReadCache readCache = getValidReadCache();
 
@@ -1397,6 +1728,7 @@ void read_cpd_tokens_from_cache_corrupted_format() throws IOException {
     readCache.put(importsMapCacheKey(inputFile.wrappedFile().key()), String.join(";", Collections.emptyList()).getBytes(StandardCharsets.UTF_8));
     readCache.put(projectSymbolTableCacheKey(inputFile.wrappedFile().key()), serializedSymbolTable);
     readCache.put(fileContentHashCacheKey(inputFile.wrappedFile().key()), inputFile.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "MAIN".getBytes(UTF_8));
 
     TestWriteCache writeCache = new TestWriteCache();
     writeCache.bind(readCache);
@@ -1470,6 +1802,7 @@ void cpd_tokens_failure_does_not_execute_checks_multiple_times() throws IOExcept
     readCache.put(importsMapCacheKey(inputFile.wrappedFile().key()), String.join(";", Collections.emptyList()).getBytes(StandardCharsets.UTF_8));
     readCache.put(projectSymbolTableCacheKey(inputFile.wrappedFile().key()), serializedSymbolTable);
     readCache.put(fileContentHashCacheKey(inputFile.wrappedFile().key()), inputFile.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "MAIN".getBytes(UTF_8));
 
     TestWriteCache writeCache = new TestWriteCache();
     writeCache.bind(readCache);
@@ -1560,6 +1893,95 @@ void send_telemetry_sonar_tests_not_set() {
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_SONAR_TESTS_SET.key(), "0");
   }
 
+  @Test
+  void send_telemetry_heuristic_triggered_when_file_reclassified() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S930"))
+        .build())
+      .build();
+
+    inputFile(FILE_TEST_FILE, Type.MAIN);
+    var contextSpy = spy(context);
+    sensor().execute(contextSpy);
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_TEST_FILE_HEURISTIC_TRIGGERED.key(), "1");
+  }
+
+  @Test
+  void send_telemetry_heuristic_not_triggered_when_no_file_reclassified() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S930"))
+        .build())
+      .build();
+
+    inputFile(FILE_1);
+    var contextSpy = spy(context);
+    sensor().execute(contextSpy);
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_TEST_FILE_HEURISTIC_TRIGGERED.key(), "0");
+  }
+
+  @Test
+  void send_telemetry_heuristic_not_triggered_when_heuristic_inactive() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S930"))
+        .build())
+      .build();
+
+    context.setSettings(new MapSettings().setProperty("sonar.tests", "tests"));
+    inputFile(FILE_TEST_FILE, Type.MAIN);
+    var contextSpy = spy(context);
+    sensor().execute(contextSpy);
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_TEST_FILE_HEURISTIC_TRIGGERED.key(), "0");
+  }
+
+  @Test
+  void send_telemetry_analysis_uses_cache_when_optimization_active() throws IOException {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S930"))
+        .build())
+      .build();
+
+    PythonInputFile inputFile = inputFile(FILE_2, Type.MAIN, InputFile.Status.SAME);
+    TestReadCache readCache = getValidReadCache();
+    TestWriteCache writeCache = new TestWriteCache();
+    writeCache.bind(readCache);
+    byte[] serializedSymbolTable = toProtobufModuleDescriptor(Set.of(new VariableDescriptor("x", "main.x", null))).toByteArray();
+    CpdSerializer.SerializationResult cpdTokens = CpdSerializer.serialize(Collections.emptyList());
+    readCache.put(importsMapCacheKey(inputFile.wrappedFile().key()), String.join(";", Collections.emptyList()).getBytes(UTF_8));
+    readCache.put(projectSymbolTableCacheKey(inputFile.wrappedFile().key()), serializedSymbolTable);
+    readCache.put(CPD_TOKENS_CACHE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.data);
+    readCache.put(CPD_TOKENS_STRING_TABLE_KEY_PREFIX + inputFile.wrappedFile().key(), cpdTokens.stringTable);
+    readCache.put(fileContentHashCacheKey(inputFile.wrappedFile().key()), inputFile.wrappedFile().md5Hash().getBytes(UTF_8));
+    readCache.put(effectiveFileTypeCacheKey(inputFile.wrappedFile().key()), "MAIN".getBytes(UTF_8));
+    context.setPreviousCache(readCache);
+    context.setNextCache(writeCache);
+    context.setCacheEnabled(true);
+    context.setSettings(new MapSettings().setProperty("sonar.python.skipUnchanged", true));
+
+    var contextSpy = spy(context);
+    sensor().execute(contextSpy);
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_ANALYSIS_USES_CACHE.key(), "1");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_FILES_SCANNED_WITH_CACHE.key(), "1");
+  }
+
+  @Test
+  void send_telemetry_analysis_not_uses_cache_when_no_optimization() {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S930"))
+        .build())
+      .build();
+
+    inputFile(FILE_1);
+    var contextSpy = spy(context);
+    sensor().execute(contextSpy);
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_ANALYSIS_USES_CACHE.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_FILES_SCANNED_WITH_CACHE.key(), "0");
+  }
+
   @Test
   void detects_databricks() {
     activeRules = new ActiveRulesBuilder()
@@ -1590,6 +2012,20 @@ void detects_databricks_negative() {
     verify(spyContext, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_DATABRICKS_FOUND.key(), "0");
   }
 
+  @Test
+  void send_telemetry_imports_comma_separated_list() {
+    activeRules = new ActiveRulesBuilder().build();
+    // main.py contains "from mod import add"                          -> top-level module "mod" -> not in the whitelist
+    // uses_typeshed.py contains "import math" and "from fastapi ..." -> top-level modules "math", "fastapi"
+    // Result is sorted and comma-separated: "fastapi,math"
+    inputFile("main.py");
+    inputFile("uses_typeshed.py");
+    var contextSpy = spy(context);
+    sensor().execute(contextSpy);
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_IMPORTS.key(), "fastapi,math");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_IMPORTS_FORMAT_VERSION.key(), "1");
+  }
+
   @Test
   void send_telemetry_threads_and_files() {
     activeRules = new ActiveRulesBuilder()
@@ -1611,7 +2047,7 @@ void send_telemetry_threads_and_files() {
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.ANALYSIS_THREADS_PARAM_KEY.key(), "2");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PARALLEL_ANALYSIS_KEY.key(), "1");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_NUMBER_OF_FILES_KEY.key(), "2");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(eq(TelemetryMetricKey.ANALYSIS_DURATION_KEY.key()), anyString());
+    verify(contextSpy, times(1)).addTelemetryProperty(eq(TelemetryMetricKey.ANALYSIS_DURATION_KEY.key()), anyString());
   }
 
   @Test
@@ -1636,7 +2072,7 @@ void send_telemetry_threads_disabled() {
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.ANALYSIS_THREADS_KEY.key(), "1");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PARALLEL_ANALYSIS_KEY.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_NUMBER_OF_FILES_KEY.key(), "2");
-    verify(contextSpy, Mockito.times(1)).addTelemetryProperty(eq(TelemetryMetricKey.ANALYSIS_DURATION_KEY.key()), anyString());
+    verify(contextSpy, times(1)).addTelemetryProperty(eq(TelemetryMetricKey.ANALYSIS_DURATION_KEY.key()), anyString());
   }
 
   @Test
@@ -1690,7 +2126,7 @@ private PythonSensor sensor(
     ProjectConfigurationBuilder projectConfigurationBuilder) {
     FileLinesContextFactory fileLinesContextFactory = mock(FileLinesContextFactory.class);
     FileLinesContext fileLinesContext = mock(FileLinesContext.class);
-    when(fileLinesContextFactory.createFor(Mockito.any(InputFile.class))).thenReturn(fileLinesContext);
+    when(fileLinesContextFactory.createFor(any(InputFile.class))).thenReturn(fileLinesContext);
     CheckFactory checkFactory = new CheckFactory(activeRules);
     return new PythonSensor(
       fileLinesContextFactory,
@@ -1767,7 +2203,7 @@ private void setup_quickfix_sensor() throws IOException {
 
     ClientInputFile clientFile = mock(ClientInputFile.class);
 
-    when(clientFile.relativePath()).thenReturn(pathToQuickFixTestFile);
+    when(clientFile.relativePath()).thenReturn(FILE_QUICKFIX);
     when(clientFile.getPath()).thenReturn(file.getAbsolutePath());
     when(clientFile.uri()).thenReturn(file.getAbsoluteFile().toURI());
     when(clientFile.contents()).thenReturn(content);
@@ -1791,6 +2227,7 @@ private void setup_quickfix_sensor() throws IOException {
   TestReadCache getValidReadCache() {
     TestReadCache testReadCache = new TestReadCache();
     testReadCache.put(CACHE_VERSION_KEY, "unknownPluginVersion".getBytes(UTF_8));
+    testReadCache.put(TEST_SOURCES_CONFIGURED_KEY, "false".getBytes(UTF_8));
     return testReadCache;
   }
 
@@ -1841,6 +2278,7 @@ void send_telemetry_resolution_method_pyproject_toml() throws IOException {
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SONAR_SOURCES.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_CONVENTIONAL_FOLDERS.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_BASE_DIR.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_LEGACY_INIT_PY.key(), "0");
 
     // Verify build system flags
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_BUILD_SYSTEM_SETUPTOOLS.key(), "1");
@@ -1896,20 +2334,67 @@ void send_telemetry_resolution_method_setup_py() throws IOException {
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SONAR_SOURCES.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_CONVENTIONAL_FOLDERS.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_BASE_DIR.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_LEGACY_INIT_PY.key(), "0");
+  }
+
+  @Test
+  void send_telemetry_resolution_method_legacy_init_py() throws IOException {
+    // No build config files → LEGACY_INIT_PY regardless of sonar.sources or conventional folders
+    Path tempDir = Files.createTempDirectory("legacy_init_py_telemetry_test").toRealPath();
+    Path pkgDir = Files.createDirectories(tempDir.resolve("mypackage"));
+    Files.writeString(pkgDir.resolve("__init__.py"), "");
+    Files.writeString(pkgDir.resolve("module.py"), "x = 1");
+
+    SensorContextTester tempContext = SensorContextTester.create(tempDir.toFile());
+    tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
+
+    DefaultInputFile moduleFile = TestInputFileBuilder.create("moduleKey", tempDir.toFile(), pkgDir.resolve("module.py").toFile())
+      .setLanguage("py")
+      .setType(Type.MAIN)
+      .setCharset(StandardCharsets.UTF_8)
+      .build();
+    tempContext.fileSystem().add(moduleFile);
+
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(PythonRuleRepository.REPOSITORY_KEY, "S930"))
+        .build())
+      .build();
+
+    var contextSpy = spy(tempContext);
+    PythonSensor sensor = sensor(CUSTOM_RULES, null, analysisWarning, architectureUDGBuilderWrapper, new ProjectConfigurationBuilder());
+    sensor.execute(contextSpy);
+
+    // Verify resolution method flags - should use legacy __init__.py detection
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_PYPROJECT_TOML.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SETUP_PY.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SONAR_SOURCES.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_CONVENTIONAL_FOLDERS.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_BASE_DIR.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_LEGACY_INIT_PY.key(), "1");
   }
 
   @Test
   void send_telemetry_resolution_method_sonar_sources() throws IOException {
+    // Build config file exists but provides no roots; sonar.sources wins over conventional folders
     Path tempDir = Files.createTempDirectory("sonar_sources_telemetry_test").toRealPath();
     Path customDir = Files.createDirectories(tempDir.resolve(Path.of("custom_src", "mypackage")));
     Files.writeString(customDir.resolve("__init__.py"), "");
     Files.writeString(customDir.resolve("module.py"), "x = 1");
-    // No pyproject.toml, setup.py, or conventional src folder - but sonar.sources is set
+    // Minimal pyproject.toml with no package configuration so roots cannot be extracted
+    Files.writeString(tempDir.resolve("pyproject.toml"), "[project]\nname = \"myproject\"\n");
 
     SensorContextTester tempContext = SensorContextTester.create(tempDir.toFile());
     tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
     tempContext.settings().setProperty("sonar.sources", "custom_src");
 
+    DefaultInputFile pyprojectFile = TestInputFileBuilder.create("moduleKey", tempDir.toFile(), tempDir.resolve("pyproject.toml").toFile())
+      .setLanguage("py")
+      .setType(Type.MAIN)
+      .setCharset(StandardCharsets.UTF_8)
+      .build();
+    tempContext.fileSystem().add(pyprojectFile);
+
     DefaultInputFile moduleFile = TestInputFileBuilder.create("moduleKey", tempDir.toFile(), customDir.resolve("module.py").toFile())
       .setLanguage("py")
       .setType(Type.MAIN)
@@ -1927,25 +2412,35 @@ void send_telemetry_resolution_method_sonar_sources() throws IOException {
     PythonSensor sensor = sensor(CUSTOM_RULES, null, analysisWarning, architectureUDGBuilderWrapper, new ProjectConfigurationBuilder());
     sensor.execute(contextSpy);
 
-    // Verify resolution method flags - should use sonar.sources
+    // Verify resolution method flags - build config exists but no roots: sonar.sources wins
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_PYPROJECT_TOML.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SETUP_PY.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SONAR_SOURCES.key(), "1");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_CONVENTIONAL_FOLDERS.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_BASE_DIR.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_LEGACY_INIT_PY.key(), "0");
   }
 
   @Test
   void send_telemetry_resolution_method_conventional_folders() throws IOException {
+    // Build config file exists but provides no roots; conventional src/ folder wins
     Path tempDir = Files.createTempDirectory("conventional_telemetry_test").toRealPath();
     Path srcDir = Files.createDirectories(tempDir.resolve(Path.of("src", "mypackage")));
     Files.writeString(srcDir.resolve("__init__.py"), "");
     Files.writeString(srcDir.resolve("module.py"), "x = 1");
-    // No pyproject.toml or setup.py - should use conventional folder fallback
+    // Minimal pyproject.toml with no package configuration so roots cannot be extracted
+    Files.writeString(tempDir.resolve("pyproject.toml"), "[project]\nname = \"myproject\"\n");
 
     SensorContextTester tempContext = SensorContextTester.create(tempDir.toFile());
     tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
 
+    DefaultInputFile pyprojectFile = TestInputFileBuilder.create("moduleKey", tempDir.toFile(), tempDir.resolve("pyproject.toml").toFile())
+      .setLanguage("py")
+      .setType(Type.MAIN)
+      .setCharset(StandardCharsets.UTF_8)
+      .build();
+    tempContext.fileSystem().add(pyprojectFile);
+
     DefaultInputFile moduleFile = TestInputFileBuilder.create("moduleKey", tempDir.toFile(), srcDir.resolve("module.py").toFile())
       .setLanguage("py")
       .setType(Type.MAIN)
@@ -1963,25 +2458,35 @@ void send_telemetry_resolution_method_conventional_folders() throws IOException
     PythonSensor sensor = sensor(CUSTOM_RULES, null, analysisWarning, architectureUDGBuilderWrapper, new ProjectConfigurationBuilder());
     sensor.execute(contextSpy);
 
-    // Verify resolution method flags - should use conventional folders (src exists)
+    // Verify resolution method flags - build config exists but no roots: conventional folders wins
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_PYPROJECT_TOML.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SETUP_PY.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SONAR_SOURCES.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_CONVENTIONAL_FOLDERS.key(), "1");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_BASE_DIR.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_LEGACY_INIT_PY.key(), "0");
   }
 
   @Test
   void send_telemetry_resolution_method_base_dir() throws IOException {
+    // Build config file exists but provides no roots; no conventional folders, no sonar.sources → base dir
     Path tempDir = Files.createTempDirectory("basedir_telemetry_test").toRealPath();
     Path pkgDir = Files.createDirectories(tempDir.resolve("mypackage"));
     Files.writeString(pkgDir.resolve("__init__.py"), "");
     Files.writeString(pkgDir.resolve("module.py"), "x = 1");
-    // No pyproject.toml, setup.py, or src folder - should use base dir fallback
+    // Minimal pyproject.toml with no package configuration so roots cannot be extracted
+    Files.writeString(tempDir.resolve("pyproject.toml"), "[project]\nname = \"myproject\"\n");
 
     SensorContextTester tempContext = SensorContextTester.create(tempDir.toFile());
     tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
 
+    DefaultInputFile pyprojectFile = TestInputFileBuilder.create("moduleKey", tempDir.toFile(), tempDir.resolve("pyproject.toml").toFile())
+      .setLanguage("py")
+      .setType(Type.MAIN)
+      .setCharset(StandardCharsets.UTF_8)
+      .build();
+    tempContext.fileSystem().add(pyprojectFile);
+
     DefaultInputFile moduleFile = TestInputFileBuilder.create("moduleKey", tempDir.toFile(), pkgDir.resolve("module.py").toFile())
       .setLanguage("py")
       .setType(Type.MAIN)
@@ -1999,12 +2504,13 @@ void send_telemetry_resolution_method_base_dir() throws IOException {
     PythonSensor sensor = sensor(CUSTOM_RULES, null, analysisWarning, architectureUDGBuilderWrapper, new ProjectConfigurationBuilder());
     sensor.execute(contextSpy);
 
-    // Verify resolution method flags - should use base dir fallback
+    // Verify resolution method flags - build config exists but no roots, no fallback: base dir
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_PYPROJECT_TOML.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SETUP_PY.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SONAR_SOURCES.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_CONVENTIONAL_FOLDERS.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_BASE_DIR.key(), "1");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_LEGACY_INIT_PY.key(), "0");
   }
 
   @Test
@@ -2070,6 +2576,7 @@ void send_telemetry_resolution_method_both_pyproject_and_setup_py() throws IOExc
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_SONAR_SOURCES.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_CONVENTIONAL_FOLDERS.key(), "0");
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_BASE_DIR.key(), "0");
+    verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_RESOLVED_VIA_LEGACY_INIT_PY.key(), "0");
 
     // Verify build system flags - Poetry should be detected
     verify(contextSpy, times(1)).addTelemetryProperty(TelemetryMetricKey.PYTHON_PACKAGE_BUILD_SYSTEM_SETUPTOOLS.key(), "0");
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/PythonTest.java b/python-commons/src/test/java/org/sonar/plugins/python/PythonTest.java
index 2ab9104ea6..0fab2dbae9 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/PythonTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/PythonTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,8 +17,8 @@
 package org.sonar.plugins.python;
 
 import org.junit.jupiter.api.Test;
-import org.sonar.api.config.internal.ConfigurationBridge;
-import org.sonar.api.config.internal.MapSettings;
+import org.sonar.scanner.plugin.api.impl.config.ConfigurationBridge;
+import org.sonar.scanner.plugin.api.impl.config.MapSettings;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/ScannerTest.java b/python-commons/src/test/java/org/sonar/plugins/python/ScannerTest.java
index 5d9f869caf..15c37396ea 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/ScannerTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/ScannerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/TestSourceConfigurationTest.java b/python-commons/src/test/java/org/sonar/plugins/python/TestSourceConfigurationTest.java
new file mode 100644
index 0000000000..99344d9d41
--- /dev/null
+++ b/python-commons/src/test/java/org/sonar/plugins/python/TestSourceConfigurationTest.java
@@ -0,0 +1,58 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.sonar.api.config.Configuration;
+import org.sonar.scanner.plugin.api.impl.config.MapSettings;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonarsource.analyzer.commons.appsec.TestFileClassifier.HEURISTIC_DISABLED_KEY;
+
+class TestSourceConfigurationTest {
+
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("configurationCases")
+  void is_configured(String caseName, Configuration configuration, boolean expected) {
+    assertThat(TestSourceConfiguration.isConfigured(configuration)).isEqualTo(expected);
+  }
+
+  private static Stream configurationCases() {
+    return Stream.of(
+      Arguments.of("without test-source configuration", new MapSettings().asConfig(), false),
+      Arguments.of("with a blank sonar.tests property", configurationWith("sonar.tests", "  "), false),
+      Arguments.of("with sonar.tests configured", configurationWith("sonar.tests", "tests"), true),
+      Arguments.of(
+        "with the Python heuristic enabled",
+        configurationWith("sonar.python.testFileHeuristic.disabled", "false"),
+        false),
+      Arguments.of(
+        "with the Python heuristic disabled",
+        configurationWith("sonar.python.testFileHeuristic.disabled", "true"),
+        true),
+      Arguments.of("with the common heuristic enabled", configurationWith(HEURISTIC_DISABLED_KEY, "false"), false),
+      Arguments.of("with the common heuristic disabled", configurationWith(HEURISTIC_DISABLED_KEY, "true"), true)
+    );
+  }
+
+  private static Configuration configurationWith(String key, String value) {
+    return new MapSettings().setProperty(key, value).asConfig();
+  }
+}
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/TestUtils.java b/python-commons/src/test/java/org/sonar/plugins/python/TestUtils.java
index 389dce085a..23e6610dee 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/TestUtils.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/TestUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,8 @@
  */
 package org.sonar.plugins.python;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
@@ -25,13 +27,11 @@
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.SonarRuntime;
 import org.sonar.api.batch.fs.InputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.utils.Version;
 
 public final class TestUtils {
 
-  static final SonarRuntime SONAR_RUNTIME_79 = SonarRuntimeImpl.forSonarQube(Version.create(7, 9), SonarQubeSide.SCANNER, SonarEdition.DEVELOPER);
+  static final SonarRuntime SONAR_RUNTIME_79 = TestSonarRuntime.forSonarQube(Version.create(7, 9), SonarQubeSide.SCANNER, SonarEdition.DEVELOPER);
 
   private TestUtils() {
     // Utility class
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/architecture/ArchitectureUDGBuilderWrapperTest.java b/python-commons/src/test/java/org/sonar/plugins/python/architecture/ArchitectureUDGBuilderWrapperTest.java
index 6a2d487e1d..6ade077799 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/architecture/ArchitectureUDGBuilderWrapperTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/architecture/ArchitectureUDGBuilderWrapperTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/bandit/BanditRulesDefinitionTest.java b/python-commons/src/test/java/org/sonar/plugins/python/bandit/BanditRulesDefinitionTest.java
index 5d6dd09dc6..dd03b362a7 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/bandit/BanditRulesDefinitionTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/bandit/BanditRulesDefinitionTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/bandit/BanditSensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/bandit/BanditSensorTest.java
index cf9de5411e..1128744c9f 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/bandit/BanditSensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/bandit/BanditSensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,9 @@
  */
 package org.sonar.plugins.python.bandit;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -31,16 +34,13 @@
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.TextRange;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.rule.Severity;
-import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
 import org.sonar.api.batch.sensor.issue.ExternalIssue;
 import org.sonar.api.batch.sensor.issue.IssueLocation;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.rules.RuleType;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.api.utils.Version;
+import org.sonar.scanner.plugin.api.impl.sensor.DefaultSensorDescriptor;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -212,7 +212,7 @@ private static List executeSensorImporting(int majorVersion, int
     SensorContextTester context = SensorContextTester.create(baseDir);
     try (Stream fileStream = Files.list(PROJECT_DIR)) {
       fileStream.forEach(file -> addFileToContext(context, baseDir, file));
-      context.setRuntime(SonarRuntimeImpl.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER));
+      context.setRuntime(TestSonarRuntime.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER));
       if (fileName != null) {
         String path = PROJECT_DIR.resolve(fileName).toAbsolutePath().toString();
         context.settings().setProperty("sonar.python.bandit.reportPaths", path);
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/caching/CachingTest.java b/python-commons/src/test/java/org/sonar/plugins/python/caching/CachingTest.java
index f062546def..f8f558083e 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/caching/CachingTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/caching/CachingTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -26,9 +26,9 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
+import org.sonar.api.batch.fs.InputFile;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
-import org.mockito.Mockito;
 import org.slf4j.event.Level;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.plugins.python.api.caching.PythonReadCache;
@@ -45,9 +45,12 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
+import static org.sonar.plugins.python.caching.Caching.EFFECTIVE_FILE_TYPE_CACHE_KEY_PREFIX;
 import static org.sonar.plugins.python.caching.Caching.IMPORTS_MAP_CACHE_KEY_PREFIX;
 import static org.sonar.plugins.python.caching.Caching.PROJECT_SYMBOL_TABLE_CACHE_KEY_PREFIX;
+import static org.sonar.plugins.python.caching.Caching.effectiveFileTypeCacheKey;
 import static org.sonar.python.index.DescriptorsToProtobuf.fromProtobuf;
 
 class CachingTest {
@@ -117,10 +120,10 @@ void readProjectLevelSymbolTableIOException() throws IOException {
     TestReadCache readCache = new TestReadCache();
     InputStream inputStream = mock(InputStream.class);
     when(inputStream.readAllBytes()).thenThrow(new IOException("Boom!"));
-    PythonReadCacheImpl pythonReadCache = Mockito.spy(new PythonReadCacheImpl(readCache));
+    PythonReadCacheImpl pythonReadCache = spy(new PythonReadCacheImpl(readCache));
     String cacheKey = PROJECT_SYMBOL_TABLE_CACHE_KEY_PREFIX + "mod";
     readCache.put(cacheKey, new byte[0]);
-    Mockito.when(pythonReadCache.read(cacheKey)).thenReturn(inputStream);
+    when(pythonReadCache.read(cacheKey)).thenReturn(inputStream);
 
     CacheContextImpl cacheContext = new CacheContextImpl(true, new PythonWriteCacheImpl(writeCache), pythonReadCache);
     Caching caching = new Caching(cacheContext, CACHE_VERSION);
@@ -186,4 +189,81 @@ void corruptedDataInCache() {
     assertThat(caching.readProjectLevelSymbolTableEntry(module)).isNull();
     assertThat(logTester.logs(Level.DEBUG)).contains("Failed to deserialize project level symbol table entry for module: \"mod\"");
   }
+
+  @Test
+  void writeAndReadEffectiveFileType() {
+    TestWriteCache writeCache = new TestWriteCache();
+    TestReadCache readCache = new TestReadCache();
+    writeCache.bind(readCache);
+    CacheContextImpl cacheContext = new CacheContextImpl(true, new PythonWriteCacheImpl(writeCache), new PythonReadCacheImpl(readCache));
+
+    Caching caching = new Caching(cacheContext, CACHE_VERSION);
+
+    caching.writeEffectiveFileType("module:src/helper.py", InputFile.Type.MAIN);
+    assertThat(writeCache.getData()).containsKey(EFFECTIVE_FILE_TYPE_CACHE_KEY_PREFIX + "module:src/helper.py");
+
+    caching.writeEffectiveFileType("module:src/test_helper.py", InputFile.Type.TEST);
+    assertThat(writeCache.getData()).containsKey(EFFECTIVE_FILE_TYPE_CACHE_KEY_PREFIX + "module:src/test_helper.py");
+
+    readCache.put(effectiveFileTypeCacheKey("module:src/helper.py"), "MAIN".getBytes(StandardCharsets.UTF_8));
+    readCache.put(effectiveFileTypeCacheKey("module:src/test_helper.py"), "TEST".getBytes(StandardCharsets.UTF_8));
+    assertThat(caching.readEffectiveFileType("module:src/helper.py")).isEqualTo(InputFile.Type.MAIN);
+    assertThat(caching.readEffectiveFileType("module:src/test_helper.py")).isEqualTo(InputFile.Type.TEST);
+  }
+
+  @Test
+  void readEffectiveFileTypeMissingEntry() {
+    TestWriteCache writeCache = new TestWriteCache();
+    TestReadCache readCache = new TestReadCache();
+    CacheContextImpl cacheContext = new CacheContextImpl(true, new PythonWriteCacheImpl(writeCache), new PythonReadCacheImpl(readCache));
+
+    Caching caching = new Caching(cacheContext, CACHE_VERSION);
+    assertThat(caching.readEffectiveFileType("module:src/unknown.py")).isNull();
+  }
+
+  @Test
+  void isTestSourcesConfiguredUnchangedReturnsFalseForInvalidCachedValue() {
+    TestWriteCache writeCache = new TestWriteCache();
+    TestReadCache readCache = new TestReadCache();
+    CacheContextImpl cacheContext = new CacheContextImpl(true, new PythonWriteCacheImpl(writeCache), new PythonReadCacheImpl(readCache));
+    Caching caching = new Caching(cacheContext, CACHE_VERSION);
+
+    readCache.put(Caching.TEST_SOURCES_CONFIGURED_KEY, "INVALID".getBytes(StandardCharsets.UTF_8));
+    // unrecognised value must never be treated as "unchanged" — always invalidate
+    assertThat(caching.isTestSourcesConfiguredUnchanged(false)).isFalse();
+    assertThat(caching.isTestSourcesConfiguredUnchanged(true)).isFalse();
+  }
+
+  @Test
+  void readEffectiveFileTypeReturnsNullForInvalidCachedValue() {
+    TestWriteCache writeCache = new TestWriteCache();
+    TestReadCache readCache = new TestReadCache();
+    CacheContextImpl cacheContext = new CacheContextImpl(true, new PythonWriteCacheImpl(writeCache), new PythonReadCacheImpl(readCache));
+    Caching caching = new Caching(cacheContext, CACHE_VERSION);
+
+    readCache.put(effectiveFileTypeCacheKey("module:src/helper.py"), "INVALID_TYPE".getBytes(StandardCharsets.UTF_8));
+    assertThat(caching.readEffectiveFileType("module:src/helper.py")).isNull();
+  }
+
+  @Test
+  void copyFromPreviousCopiesThreeIndexingKeys() {
+    TestWriteCache writeCache = new TestWriteCache();
+    TestReadCache readCache = new TestReadCache();
+    writeCache.bind(readCache);
+    CacheContextImpl cacheContext = new CacheContextImpl(true, new PythonWriteCacheImpl(writeCache), new PythonReadCacheImpl(readCache));
+
+    Caching caching = new Caching(cacheContext, CACHE_VERSION);
+    String fileKey = "module:src/helper.py";
+    readCache.put(Caching.importsMapCacheKey(fileKey), new byte[0]);
+    readCache.put(Caching.projectSymbolTableCacheKey(fileKey), new byte[0]);
+    readCache.put(Caching.fileContentHashCacheKey(fileKey), new byte[0]);
+
+    caching.copyFromPrevious(fileKey);
+
+    assertThat(writeCache.getData())
+      .containsKey(Caching.importsMapCacheKey(fileKey))
+      .containsKey(Caching.projectSymbolTableCacheKey(fileKey))
+      .containsKey(Caching.fileContentHashCacheKey(fileKey))
+      .doesNotContainKey(effectiveFileTypeCacheKey(fileKey));
+  }
 }
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/caching/TestReadCache.java b/python-commons/src/test/java/org/sonar/plugins/python/caching/TestReadCache.java
index 1264664f9e..0eff260fb4 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/caching/TestReadCache.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/caching/TestReadCache.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/caching/TestWriteCache.java b/python-commons/src/test/java/org/sonar/plugins/python/caching/TestWriteCache.java
index 0a9d840fa0..455fb09c17 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/caching/TestWriteCache.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/caching/TestWriteCache.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/coverage/PythonCoverageSensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/coverage/PythonCoverageSensorTest.java
index 417401340d..83fbcb31f9 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/coverage/PythonCoverageSensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/coverage/PythonCoverageSensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -28,15 +28,14 @@
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.api.io.TempDir;
 import org.mockito.MockedStatic;
-import org.mockito.Mockito;
 import org.slf4j.event.Level;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.InputFile.Type;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
-import org.sonar.api.config.internal.MapSettings;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultInputFile;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import org.sonar.scanner.plugin.api.impl.sensor.DefaultSensorDescriptor;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import org.sonar.scanner.plugin.api.impl.config.MapSettings;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.plugins.python.PythonReportSensor;
 import org.sonar.plugins.python.TestUtils;
@@ -46,6 +45,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.contains;
+import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -306,7 +306,7 @@ void should_do_nothing_on_empty_report() {
 
   @Test
   void should_warn_on_invalid_basedir() {
-    try(MockedStatic pythonReportSensorMock = Mockito.mockStatic(PythonReportSensor.class)) {
+    try(MockedStatic pythonReportSensorMock = mockStatic(PythonReportSensor.class)) {
       pythonReportSensorMock
         .when(() -> PythonReportSensor.getReports(any(), any(), any(), any(), any()))
         .thenThrow(RuntimeException.class);
@@ -316,14 +316,105 @@ void should_warn_on_invalid_basedir() {
     }
   }
 
+  @Test
+  void should_resolve_relative_source_against_project_base_dir() throws Exception {
+    Path projectBaseDir = tmpDir.resolve(".tests/resources/python-app");
+    Path sourceDir = Files.createDirectories(projectBaseDir.resolve("my_app"));
+    Path sourceFile = sourceDir.resolve("__init__.py");
+    Files.writeString(sourceFile, "print('hello')\n", UTF_8);
+
+    Path report = projectBaseDir.resolve("coverage.xml");
+    Files.writeString(report, """
+      
+      
+        
+          my_app
+        
+        
+          
+            
+              
+                
+                  
+                
+              
+            
+          
+        
+      
+      """, UTF_8);
+
+    SensorContextTester sensorContext = SensorContextTester.create(projectBaseDir.toFile());
+    MapSettings sensorSettings = new MapSettings();
+    sensorSettings.setProperty(PythonCoverageSensor.REPORT_PATHS_KEY, "coverage.xml");
+    sensorContext.setSettings(sensorSettings);
+
+    DefaultInputFile inputFile = TestInputFileBuilder.create("moduleKey", "my_app/__init__.py")
+      .setModuleBaseDir(projectBaseDir)
+      .setLanguage("py")
+      .setType(Type.MAIN)
+      .initMetadata(TestUtils.fileContent(sourceFile.toFile(), StandardCharsets.UTF_8))
+      .build();
+    sensorContext.fileSystem().add(inputFile);
+
+    coverageSensor.execute(sensorContext);
+
+    assertThat(sensorContext.lineHits("moduleKey:my_app/__init__.py", 1)).isOne();
+  }
+
+  @Test
+  void should_resolve_absolute_source_path_independently_of_project_base_dir() throws Exception {
+    Path projectBaseDir = tmpDir.resolve(".tests/resources/python-app-abs");
+    Path sourceDir = Files.createDirectories(projectBaseDir.resolve("my_app"));
+    Path sourceFile = sourceDir.resolve("__init__.py");
+    Files.writeString(sourceFile, "print('hello')\n", UTF_8);
+
+    String absoluteSourceDir = sourceDir.toAbsolutePath().toString();
+    Path report = projectBaseDir.resolve("coverage.xml");
+    Files.writeString(report, """
+      
+      
+        
+          %s
+        
+        
+          
+            
+              
+                
+                  
+                
+              
+            
+          
+        
+      
+      """.formatted(absoluteSourceDir), UTF_8);
+
+    SensorContextTester sensorContext = SensorContextTester.create(projectBaseDir.toFile());
+    MapSettings sensorSettings = new MapSettings();
+    sensorSettings.setProperty(PythonCoverageSensor.REPORT_PATHS_KEY, "coverage.xml");
+    sensorContext.setSettings(sensorSettings);
+
+    DefaultInputFile inputFile = TestInputFileBuilder.create("moduleKey", "my_app/__init__.py")
+      .setModuleBaseDir(projectBaseDir)
+      .setLanguage("py")
+      .setType(Type.MAIN)
+      .initMetadata(TestUtils.fileContent(sourceFile.toFile(), StandardCharsets.UTF_8))
+      .build();
+    sensorContext.fileSystem().add(inputFile);
+
+    coverageSensor.execute(sensorContext);
+
+    assertThat(sensorContext.lineHits("moduleKey:my_app/__init__.py", 1)).isOne();
+  }
+
   @Test
   void should_warn_if_source_is_not_directory() {
     settings.setProperty(PythonCoverageSensor.REPORT_PATHS_KEY, "coverage_source_invalid_directory.xml");
     coverageSensor.execute(context);
-    File file1 = new File("src/test/resources/org/sonar/plugins/python/coverage-reports/sources/file1.py");
-    File file2 = new File("src/test/resources/org/sonar/plugins/python/coverage-reports/sources/file2.py");
-    String message1 = "Invalid directory path in 'source' element: " + file1.getPath();
-    String message2 = "Invalid directory path in 'source' element: " + file2.getPath();
+    String message1 = "Invalid directory path in 'source' element: sources" + File.separator + "file1.py";
+    String message2 = "Invalid directory path in 'source' element: sources" + File.separator + "file2.py";
     assertThat(logTester.logs(Level.WARN)).contains(message1);
     assertThat(logTester.logs(Level.WARN)).contains(message2);
     verify(analysisWarnings, times(1)).addUnique("The following error(s) occurred while trying to import coverage report:" + System.lineSeparator() + message1 + System.lineSeparator() + message2);
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/cpd/PythonCpdAnalyzerTest.java b/python-commons/src/test/java/org/sonar/plugins/python/cpd/PythonCpdAnalyzerTest.java
index 97be623263..d463773d76 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/cpd/PythonCpdAnalyzerTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/cpd/PythonCpdAnalyzerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -23,10 +23,10 @@
 import java.util.concurrent.locks.ReentrantLock;
 import org.junit.jupiter.api.Test;
 import org.sonar.api.batch.fs.InputFile;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.batch.sensor.cpd.internal.TokensLine;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultInputFile;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import org.sonar.duplications.internal.pmd.TokensLine;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
 import org.sonar.plugins.python.Python;
 import org.sonar.plugins.python.TestUtils;
 import org.sonar.plugins.python.api.PythonVisitorContext;
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/dependency/DependencyPostProcessorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/dependency/DependencyPostProcessorTest.java
index a43e9df784..c4dda615a4 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/dependency/DependencyPostProcessorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/dependency/DependencyPostProcessorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/dependency/DependencyTelemetryTest.java b/python-commons/src/test/java/org/sonar/plugins/python/dependency/DependencyTelemetryTest.java
index b2cbf76c28..b4638f6079 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/dependency/DependencyTelemetryTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/dependency/DependencyTelemetryTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -25,8 +25,8 @@
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentMatcher;
 import org.sonar.api.batch.fs.InputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
 import org.sonar.plugins.python.telemetry.SensorTelemetryStorage;
 import org.sonar.plugins.python.telemetry.TelemetryMetricKey;
 
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/dependency/PyProjectTomlParserTest.java b/python-commons/src/test/java/org/sonar/plugins/python/dependency/PyProjectTomlParserTest.java
index beec88ab7f..b2707db66b 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/dependency/PyProjectTomlParserTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/dependency/PyProjectTomlParserTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,7 +22,7 @@
 import org.assertj.core.api.Assertions;
 import org.assertj.core.api.ObjectAssert;
 import org.junit.jupiter.api.Test;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
 import org.sonar.plugins.python.dependency.model.Dependencies;
 import org.sonar.plugins.python.dependency.model.Dependency;
 
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/dependency/RequirementsTxtParserTest.java b/python-commons/src/test/java/org/sonar/plugins/python/dependency/RequirementsTxtParserTest.java
index e3d75b6b6e..dbe0b744bd 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/dependency/RequirementsTxtParserTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/dependency/RequirementsTxtParserTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,8 +21,8 @@
 import java.io.IOException;
 import java.nio.file.Path;
 import org.junit.jupiter.api.Test;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultInputFile;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
 import org.sonar.plugins.python.TestUtils;
 import org.sonar.plugins.python.dependency.model.Dependencies;
 import org.sonar.plugins.python.dependency.model.Dependency;
@@ -58,7 +58,14 @@ void parse_requirement_files() {
       "packagewithleadingspaces",
       "packagewithfixedversion",
       "packagewithconstraints",
-      "packagewithvcs");
+      "packagewithvcs",
+      "torch",
+      "labml-helpers",
+      "gym",
+      "numpy",
+      "flask",
+      "requests",
+      "certifi");
   }
 
   private DefaultInputFile createRequirementFile() {
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/dependency/model/DependencyTest.java b/python-commons/src/test/java/org/sonar/plugins/python/dependency/model/DependencyTest.java
index 55a291ca68..bfc582976c 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/dependency/model/DependencyTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/dependency/model/DependencyTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/editions/OpenSourceRepositoryInfoProviderTest.java b/python-commons/src/test/java/org/sonar/plugins/python/editions/OpenSourceRepositoryInfoProviderTest.java
index df351f76d2..0ff15677f6 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/editions/OpenSourceRepositoryInfoProviderTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/editions/OpenSourceRepositoryInfoProviderTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/editions/RepositoryInfoProviderWrapperTest.java b/python-commons/src/test/java/org/sonar/plugins/python/editions/RepositoryInfoProviderWrapperTest.java
index adf55d720c..b1c0cd78aa 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/editions/RepositoryInfoProviderWrapperTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/editions/RepositoryInfoProviderWrapperTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/flake8/Flake8RulesDefinitionTest.java b/python-commons/src/test/java/org/sonar/plugins/python/flake8/Flake8RulesDefinitionTest.java
index 4a2ad1536b..04000ad0e5 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/flake8/Flake8RulesDefinitionTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/flake8/Flake8RulesDefinitionTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/flake8/Flake8SensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/flake8/Flake8SensorTest.java
index bf5ddab2b2..536f96bcc0 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/flake8/Flake8SensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/flake8/Flake8SensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,9 @@
  */
 package org.sonar.plugins.python.flake8;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -31,16 +34,13 @@
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.TextRange;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.rule.Severity;
-import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
 import org.sonar.api.batch.sensor.issue.ExternalIssue;
 import org.sonar.api.batch.sensor.issue.IssueLocation;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.rules.RuleType;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.api.utils.Version;
+import org.sonar.scanner.plugin.api.impl.sensor.DefaultSensorDescriptor;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -201,7 +201,7 @@ private static List executeSensorImporting(int majorVersion, int
     SensorContextTester context = SensorContextTester.create(baseDir);
     try (Stream fileStream = Files.list(PROJECT_DIR)) {
       fileStream.forEach(file -> addFileToContext(context, baseDir, file));
-      context.setRuntime(SonarRuntimeImpl.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER));
+      context.setRuntime(TestSonarRuntime.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER));
       if (fileName != null) {
         String path = PROJECT_DIR.resolve(fileName).toAbsolutePath().toString();
         context.settings().setProperty("sonar.python.flake8.reportPaths", path);
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/ConfigSourceRootsTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/ConfigSourceRootsTest.java
index 03ed0d3361..ec5d6508b2 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/ConfigSourceRootsTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/ConfigSourceRootsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/NamespacePackageAnalyzerTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/NamespacePackageAnalyzerTest.java
index e677cc994e..e5892636d0 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/NamespacePackageAnalyzerTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/NamespacePackageAnalyzerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -257,10 +257,10 @@ void telemetry_with_resolution_info_can_be_created() {
     NamespacePackageTelemetry baseTelemetry = analyzer.analyze(emptyTree);
 
     NamespacePackageTelemetry withResolution = baseTelemetry.withResolutionInfo(
-      PackageResolutionResult.ResolutionMethod.PYPROJECT_TOML,
+      PackageResolutionResult.PrimaryResolutionMethod.PYPROJECT_TOML,
       PackageResolutionResult.BuildSystem.SETUPTOOLS);
 
-    assertThat(withResolution.resolutionMethod()).isEqualTo(PackageResolutionResult.ResolutionMethod.PYPROJECT_TOML);
+    assertThat(withResolution.resolutionMethod()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.PYPROJECT_TOML);
     assertThat(withResolution.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.SETUPTOOLS);
     // Original values preserved
     assertThat(withResolution.packagesWithInit()).isEqualTo(baseTelemetry.packagesWithInit());
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PackageResolutionResultTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PackageResolutionResultTest.java
index 9cf58e3387..419a4d632d 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PackageResolutionResultTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PackageResolutionResultTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -29,7 +29,7 @@ void fromPyProjectToml_creates_correct_result() {
     var result = PackageResolutionResult.fromPyProjectToml(roots, PackageResolutionResult.BuildSystem.SETUPTOOLS);
 
     assertThat(result.roots()).containsExactly("/project/src");
-    assertThat(result.method()).isEqualTo(PackageResolutionResult.ResolutionMethod.PYPROJECT_TOML);
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.PYPROJECT_TOML);
     assertThat(result.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.SETUPTOOLS);
   }
 
@@ -39,7 +39,7 @@ void fromSetupPy_creates_correct_result() {
     var result = PackageResolutionResult.fromSetupPy(roots);
 
     assertThat(result.roots()).containsExactly("/project/src");
-    assertThat(result.method()).isEqualTo(PackageResolutionResult.ResolutionMethod.SETUP_PY);
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.SETUP_PY);
     assertThat(result.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.NONE);
   }
 
@@ -49,7 +49,7 @@ void fromSonarSources_creates_correct_result() {
     var result = PackageResolutionResult.fromSonarSources(roots);
 
     assertThat(result.roots()).containsExactly("/project/src", "/project/lib");
-    assertThat(result.method()).isEqualTo(PackageResolutionResult.ResolutionMethod.SONAR_SOURCES);
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.SONAR_SOURCES);
     assertThat(result.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.NONE);
   }
 
@@ -59,7 +59,7 @@ void fromConventionalFolders_creates_correct_result() {
     var result = PackageResolutionResult.fromConventionalFolders(roots);
 
     assertThat(result.roots()).containsExactly("/project/src");
-    assertThat(result.method()).isEqualTo(PackageResolutionResult.ResolutionMethod.CONVENTIONAL_FOLDERS);
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.CONVENTIONAL_FOLDERS);
     assertThat(result.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.NONE);
   }
 
@@ -69,7 +69,17 @@ void fromBaseDir_creates_correct_result() {
     var result = PackageResolutionResult.fromBaseDir(roots);
 
     assertThat(result.roots()).containsExactly("/project");
-    assertThat(result.method()).isEqualTo(PackageResolutionResult.ResolutionMethod.BASE_DIR);
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.BASE_DIR);
+    assertThat(result.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.NONE);
+  }
+
+  @Test
+  void fromLegacyInitPy_creates_correct_result() {
+    List roots = List.of("/project", "/project/other");
+    var result = PackageResolutionResult.fromLegacyInitPy(roots);
+
+    assertThat(result.roots()).containsExactly("/project", "/project/other");
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
     assertThat(result.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.NONE);
   }
 
@@ -90,13 +100,14 @@ void all_build_systems_exist() {
 
   @Test
   void all_resolution_methods_exist() {
-    assertThat(PackageResolutionResult.ResolutionMethod.values()).containsExactly(
-      PackageResolutionResult.ResolutionMethod.PYPROJECT_TOML,
-      PackageResolutionResult.ResolutionMethod.SETUP_PY,
-      PackageResolutionResult.ResolutionMethod.PYPROJECT_AND_SETUP_PY,
-      PackageResolutionResult.ResolutionMethod.SONAR_SOURCES,
-      PackageResolutionResult.ResolutionMethod.CONVENTIONAL_FOLDERS,
-      PackageResolutionResult.ResolutionMethod.BASE_DIR
+    assertThat(PackageResolutionResult.PrimaryResolutionMethod.values()).containsExactly(
+      PackageResolutionResult.PrimaryResolutionMethod.PYPROJECT_TOML,
+      PackageResolutionResult.PrimaryResolutionMethod.SETUP_PY,
+      PackageResolutionResult.PrimaryResolutionMethod.PYPROJECT_AND_SETUP_PY,
+      PackageResolutionResult.PrimaryResolutionMethod.SONAR_SOURCES,
+      PackageResolutionResult.PrimaryResolutionMethod.CONVENTIONAL_FOLDERS,
+      PackageResolutionResult.PrimaryResolutionMethod.BASE_DIR,
+      PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY
     );
   }
 
@@ -106,7 +117,7 @@ void fromBothPyProjectAndSetupPy_creates_correct_result() {
     var result = PackageResolutionResult.fromBothPyProjectAndSetupPy(roots, PackageResolutionResult.BuildSystem.SETUPTOOLS);
 
     assertThat(result.roots()).containsExactly("/project/src", "/project/lib");
-    assertThat(result.method()).isEqualTo(PackageResolutionResult.ResolutionMethod.PYPROJECT_AND_SETUP_PY);
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.PYPROJECT_AND_SETUP_PY);
     assertThat(result.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.SETUPTOOLS);
   }
 }
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PackageRootResolverTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PackageRootResolverTest.java
index 1d7421a6f9..21017fbaef 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PackageRootResolverTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PackageRootResolverTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,8 +21,11 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
+import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
+import org.sonar.api.batch.fs.FileSystem;
+import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.config.Configuration;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -34,128 +37,317 @@ class PackageRootResolverTest {
   @TempDir
   Path tempDir;
 
-  @Test
-  void resolve_withExtractedRoots_returnsThemDirectly() {
-    // Extracted roots are now expected to be already absolute paths
-    // (resolved relative to the config file location by PythonIndexer)
+  // ─── Helpers ───────────────────────────────────────────────────────────────
+
+  private FileSystem mockFileSystem(File baseDir) {
+    FileSystem fs = mock(FileSystem.class);
+    when(fs.baseDir()).thenReturn(baseDir);
+    return fs;
+  }
+
+  private InputFile mockInputFile(File file) {
+    InputFile inputFile = mock(InputFile.class);
+    when(inputFile.file()).thenReturn(file);
+    return inputFile;
+  }
+
+  private Configuration noSonarSources() {
     Configuration config = mock(Configuration.class);
     when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
+    return config;
+  }
+
+  private Configuration sonarSources(String... values) {
+    Configuration config = mock(Configuration.class);
+    when(config.getStringArray("sonar.sources")).thenReturn(values);
+    return config;
+  }
 
+  // ─── resolve() — no build config files → LEGACY_INIT_PY ──────────────────
+
+  @Test
+  void resolve_noBuildConfigFiles_noPythonFiles_returnsBaseDirAsRoot() {
     File baseDir = tempDir.toFile();
-    List extractedRoots = List.of(
-      new File(baseDir, "subproject/src").getAbsolutePath(),
-      new File(baseDir, "subproject/lib").getAbsolutePath()
-    );
-    List result = PackageRootResolver.resolve(extractedRoots, config, baseDir);
 
-    // Should return the paths as-is since they're already absolute
-    assertThat(result).containsExactly(
-      new File(baseDir, "subproject/src").getAbsolutePath(),
-      new File(baseDir, "subproject/lib").getAbsolutePath());
+    PackageResolutionResult result = PackageRootResolver.resolve(mockFileSystem(baseDir), noSonarSources(), List.of());
+
+    assertThat(result.roots()).containsExactly(baseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
   }
 
   @Test
-  void resolve_withExtractedRoots_ignoresSonarSources() {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[]{"other"});
+  void resolve_inaccessibleBaseDir_fallsBackToLegacyResolution() {
+    File missingBaseDir = tempDir.resolve("missing").toFile();
 
-    File baseDir = tempDir.toFile();
-    // Extracted roots are already absolute paths
-    List extractedRoots = List.of(new File(baseDir, "app/src").getAbsolutePath());
-    List result = PackageRootResolver.resolve(extractedRoots, config, baseDir);
+    PackageResolutionResult result = PackageRootResolver.resolve(mockFileSystem(missingBaseDir), noSonarSources(), List.of());
 
-    // Should return the extracted root as-is, ignoring sonar.sources
-    assertThat(result).containsExactly(new File(baseDir, "app/src").getAbsolutePath());
+    assertThat(result.roots()).containsExactly(missingBaseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
   }
 
   @Test
-  void resolve_emptyExtractedRoots_fallsBackToSonarSources() {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[]{"sources", "lib"});
-
+  void resolve_noBuildConfigFiles_filesWithNoInitPy_returnsParentDirsAsRoots() throws IOException {
+    // Files with no __init__.py in their parent: root is the parent dir itself
     File baseDir = tempDir.toFile();
-    List result = PackageRootResolver.resolve(List.of(), config, baseDir);
+    File pkgDir = tempDir.resolve("mypkg").toFile();
+    pkgDir.mkdir();
+    File pyFile = new File(pkgDir, "module.py");
+    pyFile.createNewFile();
 
-    assertThat(result).containsExactly(
-      new File(baseDir, "sources").getAbsolutePath(),
-      new File(baseDir, "lib").getAbsolutePath());
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), noSonarSources(), List.of(mockInputFile(pyFile)));
+
+    // mypkg/ has no __init__.py, so root is mypkg/ itself
+    assertThat(result.roots()).containsExactly(pkgDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
   }
 
   @Test
-  void resolve_emptyExtractedRootsAndNoSonarSources_fallsBackToSrcFolder() throws IOException {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
-
+  void resolve_noBuildConfigFiles_filesWithInitPy_walksUpToFindRoot() throws IOException {
+    // pkg/__init__.py exists → root walks up to baseDir
     File baseDir = tempDir.toFile();
+    File pkgDir = tempDir.resolve("mypkg").toFile();
+    pkgDir.mkdir();
+    new File(pkgDir, "__init__.py").createNewFile();
+    File pyFile = new File(pkgDir, "module.py");
+    pyFile.createNewFile();
+
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), noSonarSources(), List.of(mockInputFile(pyFile)));
+
+    // mypkg/ has __init__.py → walk up → baseDir has no __init__.py → root = baseDir
+    assertThat(result.roots()).containsExactly(baseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
+  }
+
+  @Test
+  void resolve_noBuildConfigFiles_srcFolderPresent_stillComputesLegacyRoots() throws IOException {
+    // Conventional folders are irrelevant when no build config files exist; roots come from __init__.py walk
     Files.createDirectory(tempDir.resolve("src"));
+    File baseDir = tempDir.toFile();
+    File pkgDir = tempDir.resolve("mypkg").toFile();
+    pkgDir.mkdir();
+    new File(pkgDir, "__init__.py").createNewFile();
+    File pyFile = new File(pkgDir, "module.py");
+    pyFile.createNewFile();
 
-    List result = PackageRootResolver.resolve(List.of(), config, baseDir);
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), noSonarSources(), List.of(mockInputFile(pyFile)));
 
-    assertThat(result).containsExactly(new File(baseDir, "src").getAbsolutePath());
+    assertThat(result.roots()).containsExactly(baseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
   }
 
   @Test
-  void resolve_emptyExtractedRootsAndNoSonarSources_fallsBackToLibFolder() throws IOException {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
+  void resolve_noBuildConfigFiles_sonarSourcesIgnored() throws IOException {
+    // sonar.sources is also irrelevant when no build config files exist
+    File baseDir = tempDir.toFile();
+    File pkgDir = tempDir.resolve("mypkg").toFile();
+    pkgDir.mkdir();
+    new File(pkgDir, "__init__.py").createNewFile();
+    File pyFile = new File(pkgDir, "module.py");
+    pyFile.createNewFile();
 
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), sonarSources("."), List.of(mockInputFile(pyFile)));
+
+    assertThat(result.roots()).containsExactly(baseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
+  }
+
+  @Test
+  void resolve_noBuildConfigFiles_multiplePackages_multipleRootsSortedDeepestFirst() throws IOException {
+    // Two independent packages at different depths → two roots, sorted deepest first
     File baseDir = tempDir.toFile();
-    Files.createDirectory(tempDir.resolve("lib"));
 
-    List result = PackageRootResolver.resolve(List.of(), config, baseDir);
+    File shallowDir = tempDir.resolve("shallow").toFile();
+    shallowDir.mkdir();
+    new File(shallowDir, "__init__.py").createNewFile();
+    File shallowFile = new File(shallowDir, "mod.py");
+    shallowFile.createNewFile();
+
+    File deepParentDir = tempDir.resolve("deep").toFile();
+    deepParentDir.mkdir();
+    File deepPkgDir = new File(deepParentDir, "nested");
+    deepPkgDir.mkdir();
+    new File(deepPkgDir, "__init__.py").createNewFile();
+    File deepFile = new File(deepPkgDir, "mod.py");
+    deepFile.createNewFile();
+
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), noSonarSources(),
+      List.of(mockInputFile(shallowFile), mockInputFile(deepFile)));
+
+    // shallow/ has __init__.py → root = baseDir
+    // deep/nested/ has __init__.py, deep/ does not → root = deep/
+    // Roots sorted deepest-first: deep/ (deeper path) before baseDir
+    assertThat(result.roots()).containsExactly(
+      deepParentDir.getAbsolutePath(),
+      baseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
+  }
 
-    assertThat(result).containsExactly(new File(baseDir, "lib").getAbsolutePath());
+  @Test
+  void resolve_noBuildConfigFiles_nestedInitPyChain_walksUpToCorrectRoot() throws IOException {
+    // level1/__init__.py, level1/level2/__init__.py, level1/level2/level3/__init__.py
+    // file at level3/ → root should be baseDir
+    File baseDir = tempDir.toFile();
+    File l1 = new File(baseDir, "level1");
+    File l2 = new File(l1, "level2");
+    File l3 = new File(l2, "level3");
+    l3.mkdirs();
+    new File(l1, "__init__.py").createNewFile();
+    new File(l2, "__init__.py").createNewFile();
+    new File(l3, "__init__.py").createNewFile();
+    File pyFile = new File(l3, "mod.py");
+    pyFile.createNewFile();
+
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), noSonarSources(), List.of(mockInputFile(pyFile)));
+
+    assertThat(result.roots()).containsExactly(baseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
   }
 
   @Test
-  void resolve_emptyExtractedRootsAndNoSonarSources_fallsBackToBothSrcAndLib() throws IOException {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
+  void resolve_noBuildConfigFiles_initPyGap_stopsAtGap() throws IOException {
+    // top/ (no __init__.py), top/mid/__init__.py, top/mid/bottom/__init__.py
+    // file at bottom/ → root = top/ (first parent without __init__.py)
+    File baseDir = tempDir.toFile();
+    File top = new File(baseDir, "top");
+    File mid = new File(top, "mid");
+    File bottom = new File(mid, "bottom");
+    bottom.mkdirs();
+    new File(mid, "__init__.py").createNewFile();
+    new File(bottom, "__init__.py").createNewFile();
+    File pyFile = new File(bottom, "mod.py");
+    pyFile.createNewFile();
+
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), noSonarSources(), List.of(mockInputFile(pyFile)));
+
+    // bottom has __init__.py → up to mid (has __init__.py) → up to top (no __init__.py) → root = top
+    assertThat(result.roots()).containsExactly(top.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
+  }
 
+  @Test
+  void resolve_noBuildConfigFiles_fileAtBaseDir_producesBaseDirAsRoot() throws IOException {
     File baseDir = tempDir.toFile();
+    File pyFile = new File(baseDir, "script.py");
+    pyFile.createNewFile();
+
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), noSonarSources(), List.of(mockInputFile(pyFile)));
+
+    // File is directly in baseDir, which has no __init__.py → root = baseDir
+    assertThat(result.roots()).containsExactly(baseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.LEGACY_INIT_PY);
+  }
+
+  // ─── resolve() — build config files present ───────────────────────────────
+
+  @Test
+  void resolve_buildFileExistsNoRoots_conventionalFoldersTakePriorityOverSonarSources() throws IOException {
+    // pyproject.toml exists but provides no source roots; src/ exists; sonar.sources set
+    // => conventional folders should win (build file present path)
     Files.createDirectory(tempDir.resolve("src"));
-    Files.createDirectory(tempDir.resolve("lib"));
+    Files.writeString(tempDir.resolve("pyproject.toml"), "[project]\nname = \"myproject\"\n");
+    File baseDir = tempDir.toFile();
 
-    List result = PackageRootResolver.resolve(List.of(), config, baseDir);
+    PackageResolutionResult result = PackageRootResolver.resolve(mockFileSystem(baseDir), sonarSources("app"), List.of());
 
-    assertThat(result).containsExactly(
-      new File(baseDir, "src").getAbsolutePath(),
-      new File(baseDir, "lib").getAbsolutePath());
+    assertThat(result.roots()).containsExactly(new File(baseDir, "src").getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.CONVENTIONAL_FOLDERS);
   }
 
   @Test
-  void resolve_emptyExtractedRootsNoSonarSourcesNoSrcFolder_fallsBackToBaseDirAbsolutePath() {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
+  void resolve_buildFileExistsNoRoots_fallsBackToSonarSources() throws IOException {
+    // pyproject.toml exists but provides no source roots; no conventional folders; sonar.sources set
+    Files.writeString(tempDir.resolve("pyproject.toml"), "[project]\nname = \"myproject\"\n");
+    File baseDir = tempDir.toFile();
 
+    PackageResolutionResult result = PackageRootResolver.resolve(mockFileSystem(baseDir), sonarSources("mysrc"), List.of());
+
+    assertThat(result.roots()).containsExactly(new File(baseDir, "mysrc").getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.SONAR_SOURCES);
+  }
+
+  @Test
+  void resolve_setupPyExistsNoRoots_conventionalFoldersTakePriorityOverSonarSources() throws IOException {
+    // setup.py exists but provides no source roots; src/ exists; sonar.sources set
+    Files.createDirectory(tempDir.resolve("src"));
+    Files.writeString(tempDir.resolve("setup.py"), "# empty\n");
     File baseDir = tempDir.toFile();
-    List result = PackageRootResolver.resolve(List.of(), config, baseDir);
 
-    assertThat(result).containsExactly(baseDir.getAbsolutePath());
+    PackageResolutionResult result = PackageRootResolver.resolve(mockFileSystem(baseDir), sonarSources("app"), List.of());
+
+    assertThat(result.roots()).containsExactly(new File(baseDir, "src").getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.CONVENTIONAL_FOLDERS);
   }
 
   @Test
-  void resolve_srcExistsAsFile_fallsBackToBaseDirAbsolutePath() throws IOException {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
+  void resolve_conventionalFoldersFallback_augmentsWithUncoveredFileRoots() throws IOException {
+    // pyproject.toml exists but provides no source roots; src/ exists (conventional folder);
+    // a test file lives under tests/ with __init__.py (outside src/).
+    // The fallback should augment the conventional root with a legacy root for the test file.
+    File baseDir = tempDir.toFile();
+    Files.createDirectory(tempDir.resolve("src"));
+    Files.writeString(tempDir.resolve("pyproject.toml"), "[project]\nname = \"myproject\"\n");
+
+    File testsDir = tempDir.resolve("tests").toFile();
+    testsDir.mkdir();
+    new File(testsDir, "__init__.py").createNewFile();
+    File testFile = new File(testsDir, "test_app.py");
+    testFile.createNewFile();
 
-    Files.createFile(tempDir.resolve("src"));
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), noSonarSources(), List.of(mockInputFile(testFile)));
 
+    // src/ from conventional folders + baseDir from legacy walk-up (tests/ has __init__.py)
+    assertThat(result.roots()).containsExactlyInAnyOrder(
+      new File(baseDir, "src").getAbsolutePath(),
+      baseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.CONVENTIONAL_FOLDERS);
+
+    // Verify FQN for the test file
+    String testPackageName = org.sonar.python.semantic.SymbolUtils.pythonPackageName(testFile, result.roots());
+    assertThat(testPackageName).isEqualTo("tests");
+  }
+
+  @Test
+  void resolve_sonarSourcesFallback_augmentsWithUncoveredFileRoots() throws IOException {
+    // pyproject.toml exists but provides no source roots; no conventional folders;
+    // sonar.sources=app; a test file lives under tests/ with __init__.py (outside app/).
     File baseDir = tempDir.toFile();
-    List result = PackageRootResolver.resolve(List.of(), config, baseDir);
+    Files.writeString(tempDir.resolve("pyproject.toml"), "[project]\nname = \"myproject\"\n");
 
-    assertThat(result).containsExactly(baseDir.getAbsolutePath());
+    File testsDir = tempDir.resolve("tests").toFile();
+    testsDir.mkdir();
+    new File(testsDir, "__init__.py").createNewFile();
+    File testFile = new File(testsDir, "test_app.py");
+    testFile.createNewFile();
+
+    PackageResolutionResult result = PackageRootResolver.resolve(
+      mockFileSystem(baseDir), sonarSources("app"), List.of(mockInputFile(testFile)));
+
+    // app/ from sonar.sources + baseDir from legacy walk-up (tests/ has __init__.py)
+    assertThat(result.roots()).containsExactlyInAnyOrder(
+      new File(baseDir, "app").getAbsolutePath(),
+      baseDir.getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.SONAR_SOURCES);
+
+    // Verify FQN for the test file
+    String testPackageName = org.sonar.python.semantic.SymbolUtils.pythonPackageName(testFile, result.roots());
+    assertThat(testPackageName).isEqualTo("tests");
   }
 
-  // Tests for resolveFallback method directly
+  // ─── toAbsolutePaths() — normalization ────────────────────────────────────
 
   @Test
-  void resolveFallback_withSonarSources_returnsAbsolutePaths() {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[]{"app", "core"});
-
+  void toAbsolutePaths_normalPaths_resolvedCorrectly() {
     File baseDir = tempDir.toFile();
-    List result = PackageRootResolver.resolveFallback(config, baseDir);
+    List result = PackageRootResolver.toAbsolutePaths(List.of("app", "core"), baseDir);
 
     assertThat(result).containsExactly(
       new File(baseDir, "app").getAbsolutePath(),
@@ -163,70 +355,359 @@ void resolveFallback_withSonarSources_returnsAbsolutePaths() {
   }
 
   @Test
-  void resolveFallback_noSonarSourcesButSrcExists_returnsAbsolutePath() throws IOException {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
-
+  void toAbsolutePaths_dotPath_normalizedToBaseDir() {
     File baseDir = tempDir.toFile();
-    Files.createDirectory(tempDir.resolve("src"));
+    List result = PackageRootResolver.toAbsolutePaths(List.of("."), baseDir);
+
+    // "." must normalize to baseDir, not "/baseDir/."
+    assertThat(result).containsExactly(baseDir.getAbsolutePath());
+    assertThat(result.get(0)).doesNotEndWith("/.");
+    assertThat(result.get(0)).doesNotEndWith("\\.");
+  }
+
+  // ─── toAbsolutePaths() — Windows path handling ───────────────────────────
+
+  @Test
+  void toAbsolutePaths_windowsAbsolutePath_notPrependedWithBaseDir() {
+    // When sonar.sources contains a Windows-style absolute path (e.g. from a Windows scanner),
+    // it must NOT be prepended with the base directory on a non-Windows system.
+    File baseDir = new File("/project/base");
+    String windowsAbsPath = "C:\\Users\\user\\mixed-language-build";
 
-    List result = PackageRootResolver.resolveFallback(config, baseDir);
+    List result = PackageRootResolver.toAbsolutePaths(List.of(windowsAbsPath), baseDir);
 
-    assertThat(result).containsExactly(new File(baseDir, "src").getAbsolutePath());
+    // Must not produce "/project/base/" prepended to the Windows path
+    assertThat(result).containsExactly("C:\\Users\\user\\mixed-language-build");
   }
 
   @Test
-  void resolveFallback_noSonarSourcesButLibExists_returnsAbsolutePath() throws IOException {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
+  void toAbsolutePaths_windowsAbsolutePathWithForwardSlashes_notPrependedWithBaseDir() {
+    // Windows paths may also use forward slashes; they are normalised by Path.normalize()
+    File baseDir = new File("/project/base");
+    String windowsAbsPath = "C:/Users/user/mixed-language-build";
+
+    List result = PackageRootResolver.toAbsolutePaths(List.of(windowsAbsPath), baseDir);
+
+    // Must not produce "/project/base/" prepended to the Windows path
+    // Forward slashes are preserved as-is by Path.normalize() on non-Windows systems
+    assertThat(result).hasSize(1);
+    assertThat(result.get(0)).isIn("C:\\Users\\user\\mixed-language-build", "C:/Users/user/mixed-language-build");
+  }
 
+  @Test
+  void trySonarSources_windowsAbsolutePath_usedDirectlyNotPrependedWithBaseDir() throws IOException {
+    // Full integration: build file exists, sonar.sources has a Windows absolute path.
+    // The resolved root should be derived from the Windows path, not baseDir + Windows path.
+    Files.writeString(tempDir.resolve("pyproject.toml"), "[project]\nname = \"myproject\"\n");
     File baseDir = tempDir.toFile();
-    Files.createDirectory(tempDir.resolve("lib"));
+    String windowsAbsPath = "C:\\Users\\user\\mixed-language-build";
 
-    List result = PackageRootResolver.resolveFallback(config, baseDir);
+    PackageResolutionResult result = PackageRootResolver.resolve(mockFileSystem(baseDir), sonarSources(windowsAbsPath), List.of());
 
-    assertThat(result).containsExactly(new File(baseDir, "lib").getAbsolutePath());
+    assertThat(result.method()).isEqualTo(PackageResolutionResult.PrimaryResolutionMethod.SONAR_SOURCES);
+    assertThat(result.roots()).hasSize(1);
+    assertThat(result.roots()).containsExactly("C:\\Users\\user\\mixed-language-build");
   }
 
+  // ─── adjustPackageRoot() — migrated from PythonIndexerTest ────────────────
+
   @Test
-  void resolveFallback_noSonarSourcesBothSrcAndLibExist_returnsAbsolutePaths() throws IOException {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
+  void adjustPackageRoot_noInitPy(@TempDir Path localTempDir) {
+    File baseDir = localTempDir.toFile();
+    File srcDir = new File(baseDir, "src");
+    srcDir.mkdir();
 
-    File baseDir = tempDir.toFile();
-    Files.createDirectory(tempDir.resolve("src"));
-    Files.createDirectory(tempDir.resolve("lib"));
+    String result = PackageRootResolver.adjustPackageRoot(srcDir, baseDir);
+    assertThat(result).isEqualTo(srcDir.getAbsolutePath());
+  }
 
-    List result = PackageRootResolver.resolveFallback(config, baseDir);
+  @Test
+  void adjustPackageRoot_preservesBaseDirAliasForDerivedRoot(@TempDir Path localTempDir) throws IOException {
+    Path realBaseDir = Files.createDirectories(localTempDir.resolve("real"));
+    Path derivedRoot = Files.createDirectories(realBaseDir.resolve("tests/unit"));
+    Path aliasBaseDir = localTempDir.resolve("alias");
+    try {
+      Files.createSymbolicLink(aliasBaseDir, realBaseDir);
+    } catch (UnsupportedOperationException | IOException | SecurityException e) {
+      Assumptions.assumeTrue(false, "Symbolic links are not available: " + e.getMessage());
+    }
+
+    String result = PackageRootResolver.adjustPackageRoot(derivedRoot.toFile(), aliasBaseDir.toFile());
+
+    assertThat(result).isEqualTo(aliasBaseDir.resolve("tests/unit").toAbsolutePath().toString());
+  }
 
-    assertThat(result).containsExactly(
-      new File(baseDir, "src").getAbsolutePath(),
-      new File(baseDir, "lib").getAbsolutePath());
+  @Test
+  void adjustPackageRoot_preservesRootOutsideBaseDir(@TempDir Path localTempDir) throws IOException {
+    File baseDir = Files.createDirectory(localTempDir.resolve("project")).toFile();
+    File externalRoot = Files.createDirectory(localTempDir.resolve("external")).toFile();
+
+    String result = PackageRootResolver.adjustPackageRoot(externalRoot, baseDir);
+
+    assertThat(result).isEqualTo(externalRoot.getAbsolutePath());
   }
 
   @Test
-  void resolveFallback_noSonarSourcesNoSrcNoLib_returnsBaseDirAbsolutePath() {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
+  void adjustPackageRoot_withInitPy_walksUp(@TempDir Path localTempDir) throws Exception {
+    File baseDir = localTempDir.toFile();
+    File srcDir = new File(baseDir, "src");
+    File packageDir = new File(srcDir, "mypackage");
+    packageDir.mkdirs();
+    new File(packageDir, "__init__.py").createNewFile();
+
+    String result = PackageRootResolver.adjustPackageRoot(packageDir, baseDir);
+    assertThat(result).isEqualTo(srcDir.getAbsolutePath());
+  }
+
+  @Test
+  void adjustPackageRoot_nestedPackagesWithInitPy(@TempDir Path localTempDir) throws Exception {
+    File baseDir = localTempDir.toFile();
+    File srcDir = new File(baseDir, "src");
+    File level1 = new File(srcDir, "level1");
+    File level2 = new File(level1, "level2");
+    File level3 = new File(level2, "level3");
+    level3.mkdirs();
+
+    new File(level1, "__init__.py").createNewFile();
+    new File(level2, "__init__.py").createNewFile();
+    new File(level3, "__init__.py").createNewFile();
+
+    String result = PackageRootResolver.adjustPackageRoot(level3, baseDir);
+    assertThat(result).isEqualTo(srcDir.getAbsolutePath());
+  }
+
+  @Test
+  void adjustPackageRoot_stopsAtBaseDir(@TempDir Path localTempDir) throws Exception {
+    File baseDir = localTempDir.toFile();
+    File level1 = new File(baseDir, "level1");
+    File level2 = new File(level1, "level2");
+    level2.mkdirs();
+    new File(baseDir, "__init__.py").createNewFile();
+    new File(level1, "__init__.py").createNewFile();
+    new File(level2, "__init__.py").createNewFile();
+
+    String result = PackageRootResolver.adjustPackageRoot(level2, baseDir);
+    assertThat(result).isEqualTo(baseDir.getAbsolutePath());
+  }
+
+  @Test
+  void adjustPackageRoot_rootEqualsBaseDir(@TempDir Path localTempDir) throws Exception {
+    File baseDir = localTempDir.toFile();
+    new File(baseDir, "__init__.py").createNewFile();
+
+    String result = PackageRootResolver.adjustPackageRoot(baseDir, baseDir);
+    assertThat(result).isEqualTo(baseDir.getAbsolutePath());
+  }
+
+  @Test
+  void adjustPackageRoot_partialInitPyChain(@TempDir Path localTempDir) throws Exception {
+    File baseDir = localTempDir.toFile();
+    File srcDir = new File(baseDir, "src");
+    File withInit = new File(srcDir, "withInit");
+    File withoutInit = new File(withInit, "withoutInit");
+    File deepPackage = new File(withoutInit, "deepPackage");
+    deepPackage.mkdirs();
+
+    new File(withInit, "__init__.py").createNewFile();
+    new File(deepPackage, "__init__.py").createNewFile();
+
+    String result = PackageRootResolver.adjustPackageRoot(deepPackage, baseDir);
+    assertThat(result).isEqualTo(withoutInit.getAbsolutePath());
+  }
+
+  @Test
+  void adjustPackageRoot_emptyDirectory(@TempDir Path localTempDir) {
+    File baseDir = localTempDir.toFile();
+    File emptyDir = new File(baseDir, "empty");
+    emptyDir.mkdir();
+
+    String result = PackageRootResolver.adjustPackageRoot(emptyDir, baseDir);
+    assertThat(result).isEqualTo(emptyDir.getAbsolutePath());
+  }
+
+  @Test
+  void adjustPackageRoot_singleLevelWithInitPy(@TempDir Path localTempDir) throws Exception {
+    File baseDir = localTempDir.toFile();
+    File packageDir = new File(baseDir, "mypackage");
+    packageDir.mkdir();
+    new File(packageDir, "__init__.py").createNewFile();
+
+    String result = PackageRootResolver.adjustPackageRoot(packageDir, baseDir);
+    assertThat(result).isEqualTo(baseDir.getAbsolutePath());
+  }
+
+  // ─── computePackageRootsFromFiles() ──────────────────────────────────────
+
+  @Test
+  void computePackageRootsFromFiles_empty_returns_baseDir(@TempDir Path localTempDir) {
+    File baseDir = localTempDir.toFile();
+    List roots = PackageRootResolver.computePackageRootsFromFiles(List.of(), baseDir);
+    assertThat(roots).containsExactly(baseDir.getAbsolutePath());
+  }
+
+  @Test
+  void computePackageRootsFromFiles_walks_up_init_py_chain(@TempDir Path localTempDir) throws Exception {
+    // pkg/__init__.py exists → pkg/ is a package, root should be localTempDir (parent of pkg)
+    File pkgDir = localTempDir.resolve("pkg").toFile();
+    pkgDir.mkdirs();
+    new File(pkgDir, "__init__.py").createNewFile();
+    File module = new File(pkgDir, "mod.py");
+    module.createNewFile();
+
+    List roots = PackageRootResolver.computePackageRootsFromFiles(List.of(module), localTempDir.toFile());
+    assertThat(roots).containsExactly(localTempDir.toFile().getAbsolutePath());
+  }
 
+  // ─── augmentWithUncoveredFileRoots — files outside build-config roots ───
+
+  @Test
+  void resolve_setupPyWithPackageDir_testsDirOutsideSrcRoot_augmentedWithLegacyRoot() throws IOException {
+    // Reproduces the 'black' project scenario:
+    // - setup.py declares package_dir={"": "src"}
+    // - Tests live under tests/ with __init__.py (outside src/)
+    // - The resolver must add a root for tests/ files so they get correct package names
     File baseDir = tempDir.toFile();
-    List result = PackageRootResolver.resolveFallback(config, baseDir);
 
-    assertThat(result).containsExactly(baseDir.getAbsolutePath());
+    File srcDir = tempDir.resolve("src").toFile();
+    File blackPkg = new File(srcDir, "black");
+    blackPkg.mkdirs();
+    new File(blackPkg, "__init__.py").createNewFile();
+    File srcModule = new File(blackPkg, "linegen.py");
+    srcModule.createNewFile();
+
+    File testsDir = tempDir.resolve("tests").toFile();
+    testsDir.mkdirs();
+    new File(testsDir, "__init__.py").createNewFile();
+    File testFile = new File(testsDir, "test_black.py");
+    testFile.createNewFile();
+
+    Files.writeString(tempDir.resolve("setup.py"), """
+        from setuptools import setup, find_packages
+        setup(packages=find_packages(where='src'), package_dir={'': 'src'})""");
+
+    List pythonFiles = List.of(mockInputFile(srcModule), mockInputFile(testFile));
+    PackageResolutionResult result = PackageRootResolver.resolve(mockFileSystem(baseDir), noSonarSources(), pythonFiles);
+
+    assertThat(result.roots()).contains(srcDir.getAbsolutePath());
+    // tests/ has __init__.py so the legacy root for test_black.py is baseDir
+    assertThat(result.roots()).contains(baseDir.getAbsolutePath());
+
+    // Verify that test_black.py gets the correct package name
+    String testPackageName = org.sonar.python.semantic.SymbolUtils.pythonPackageName(testFile, result.roots());
+    assertThat(testPackageName).isEqualTo("tests");
   }
 
   @Test
-  void resolveFallback_srcAndLibExistAsFiles_returnsBaseDirAbsolutePath() throws IOException {
-    Configuration config = mock(Configuration.class);
-    when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
+  void resolve_setupPyWithPackageDir_allFilesCovered_noAugmentation() throws IOException {
+    // When all files are under the build-config root, no extra roots are added
+    File baseDir = tempDir.toFile();
+
+    File srcDir = tempDir.resolve("src").toFile();
+    File pkg = new File(srcDir, "mypackage");
+    pkg.mkdirs();
+    new File(pkg, "__init__.py").createNewFile();
+    File module = new File(pkg, "mod.py");
+    module.createNewFile();
+
+    Files.writeString(tempDir.resolve("setup.py"),"""
+        from setuptools import setup, find_packages
+        setup(packages=find_packages(where='src'), package_dir={'': 'src'})""");
 
-    Files.createFile(tempDir.resolve("src"));
-    Files.createFile(tempDir.resolve("lib"));
+    List pythonFiles = List.of(mockInputFile(module));
+    PackageResolutionResult result = PackageRootResolver.resolve(mockFileSystem(baseDir), noSonarSources(), pythonFiles);
+
+    assertThat(result.roots()).containsExactly(srcDir.getAbsolutePath());
+  }
 
+  @Test
+  void resolve_setupPyWithMultipleRoots_allFilesCovered_rootsSortedDeepestFirst() throws IOException {
+    // When all files are covered (no augmentation), roots must still be sorted deepest-first.
+    // This verifies the fix for the early-return path in augmentWithUncoveredFileRoots.
     File baseDir = tempDir.toFile();
-    List result = PackageRootResolver.resolveFallback(config, baseDir);
 
-    assertThat(result).containsExactly(baseDir.getAbsolutePath());
+    // Create two source roots at different depths: src/ (shallow) and src/extra/nested/ (deep)
+    File srcDir = tempDir.resolve("src").toFile();
+    File shallowPkg = new File(srcDir, "shallowpkg");
+    shallowPkg.mkdirs();
+    new File(shallowPkg, "__init__.py").createNewFile();
+    File shallowModule = new File(shallowPkg, "mod.py");
+    shallowModule.createNewFile();
+
+    File extraNested = new File(srcDir, "extra/nested");
+    File deepPkg = new File(extraNested, "deeppkg");
+    deepPkg.mkdirs();
+    new File(deepPkg, "__init__.py").createNewFile();
+    File deepModule = new File(deepPkg, "mod.py");
+    deepModule.createNewFile();
+
+    // setup.py declares both src/ and src/extra/nested/ as package dirs
+    Files.writeString(tempDir.resolve("setup.py"), """
+        from setuptools import setup, find_packages
+        setup(
+            packages=find_packages(where='src') + find_packages(where='src/extra/nested'),
+            package_dir={'': 'src', 'deeppkg': 'src/extra/nested/deeppkg'},
+        )""");
+
+    // All files are under declared roots, so no augmentation occurs
+    List pythonFiles = List.of(mockInputFile(shallowModule), mockInputFile(deepModule));
+    PackageResolutionResult result = PackageRootResolver.resolve(mockFileSystem(baseDir), noSonarSources(), pythonFiles);
+
+    // Roots must be sorted deepest-first: src/extra/nested before src
+    assertThat(result.roots()).containsExactly(
+      extraNested.getAbsolutePath(),
+      srcDir.getAbsolutePath());
   }
-}
 
+  @Test
+  void computePackageRootsFromFiles_multiple_roots_sorted_deepest_first(@TempDir Path localTempDir) throws Exception {
+    // pkgA/__init__.py → root = localTempDir (shallow)
+    File pkgA = localTempDir.resolve("pkgA").toFile();
+    pkgA.mkdirs();
+    new File(pkgA, "__init__.py").createNewFile();
+    File modA = new File(pkgA, "mod.py");
+    modA.createNewFile();
+
+    // dir/pkgB/__init__.py → root = dir/ (deeper path)
+    File dir = localTempDir.resolve("dir").toFile();
+    File pkgB = new File(dir, "pkgB");
+    pkgB.mkdirs();
+    new File(pkgB, "__init__.py").createNewFile();
+    File modB = new File(pkgB, "mod.py");
+    modB.createNewFile();
+
+    List roots = PackageRootResolver.computePackageRootsFromFiles(List.of(modA, modB), localTempDir.toFile());
+    // dir/ is deeper (more separators) than localTempDir → dir/ comes first
+    assertThat(roots).containsExactly(
+      dir.getAbsolutePath(),
+      localTempDir.toFile().getAbsolutePath());
+  }
+
+  @Test
+  void computePackageRootsFromFiles_same_depth_sorted_alphabetically(@TempDir Path localTempDir) throws Exception {
+    // Two roots at the same depth should be sorted alphabetically
+    File baseDir = localTempDir.toFile();
+
+    // beta/pkgB/__init__.py → root = beta/
+    File betaDir = localTempDir.resolve("beta").toFile();
+    File pkgB = new File(betaDir, "pkgB");
+    pkgB.mkdirs();
+    new File(pkgB, "__init__.py").createNewFile();
+    File modB = new File(pkgB, "mod.py");
+    modB.createNewFile();
+
+    // alpha/pkgA/__init__.py → root = alpha/
+    File alphaDir = localTempDir.resolve("alpha").toFile();
+    File pkgA = new File(alphaDir, "pkgA");
+    pkgA.mkdirs();
+    new File(pkgA, "__init__.py").createNewFile();
+    File modA = new File(pkgA, "mod.py");
+    modA.createNewFile();
+
+    // Pass files in reverse alphabetical order to verify sorting is applied
+    List roots = PackageRootResolver.computePackageRootsFromFiles(List.of(modB, modA), baseDir);
+    // Same depth → alphabetical: alpha/ before beta/
+    assertThat(roots).containsExactly(
+      alphaDir.getAbsolutePath(),
+      betaDir.getAbsolutePath());
+  }
+}
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/ProjectTreeBuilderTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/ProjectTreeBuilderTest.java
index e38c61de2d..c455f4beab 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/ProjectTreeBuilderTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/ProjectTreeBuilderTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PyProjectTomlSourceRootsTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PyProjectTomlSourceRootsTest.java
index 8386366dcd..28e8ea411a 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PyProjectTomlSourceRootsTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PyProjectTomlSourceRootsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -193,6 +193,66 @@ void extract_poetry_onlyDependencies() {
       """)).isEmpty();
   }
 
+  // === Poetry Auto-Detection ===
+
+  @Test
+  void extract_poetry_autoDetect_withBuildBackend_returnsSrc() {
+    assertThat(extract("""
+      [build-system]
+      build-backend = "poetry.core.masonry.api"
+      requires = ["poetry-core"]
+
+      [tool.poetry]
+      name = "mypackage"
+      version = "0.1.0"
+      """)).containsExactly("src");
+  }
+
+  @Test
+  void extract_poetry_autoDetect_emptyPackages_returnsSrc() {
+    assertThat(extract("""
+      [build-system]
+      build-backend = "poetry.core.masonry.api"
+      requires = ["poetry-core"]
+
+      [tool.poetry]
+      packages = []
+      """)).containsExactly("src");
+  }
+
+  @Test
+  void extract_poetry_autoDetect_packagesWithoutFrom_returnsSrc() {
+    assertThat(extract("""
+      [build-system]
+      build-backend = "poetry.core.masonry.api"
+      requires = ["poetry-core"]
+
+      [tool.poetry]
+      packages = [{ include = "mypackage" }]
+      """)).containsExactly("src");
+  }
+
+  @Test
+  void extract_poetry_explicitFrom_overridesAutoDetect() {
+    assertThat(extract("""
+      [build-system]
+      build-backend = "poetry.core.masonry.api"
+      requires = ["poetry-core"]
+
+      [tool.poetry]
+      packages = [{ include = "mypackage", from = "lib" }]
+      """)).containsExactly("lib");
+  }
+
+  @Test
+  void extract_poetry_noBuildBackend_noPackages_returnsEmpty() {
+    assertThat(extract("""
+      [tool.poetry]
+      name = "mypackage"
+      version = "0.1.0"
+      """)).isEmpty();
+  }
+
   // === Hatchling ===
 
   @Test
@@ -550,6 +610,22 @@ void extractWithBuildSystem_poetry_detectsBuildSystem() {
     assertThat(result.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.POETRY);
   }
 
+  @Test
+  void extractWithBuildSystem_poetry_autoDetect_detectsBuildSystem() {
+    var result = extractWithBuildSystem("""
+      [build-system]
+      build-backend = "poetry.core.masonry.api"
+      requires = ["poetry-core"]
+
+      [tool.poetry]
+      name = "mypackage"
+      version = "0.1.0"
+      """);
+
+    assertThat(result.relativeRoots()).containsExactly("src");
+    assertThat(result.buildSystem()).isEqualTo(PackageResolutionResult.BuildSystem.POETRY);
+  }
+
   @Test
   void extractWithBuildSystem_hatchling_detectsBuildSystem() {
     var result = extractWithBuildSystem("""
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PythonIndexerTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PythonIndexerTest.java
index 384f7398a3..ccf86f531d 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PythonIndexerTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PythonIndexerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,10 +16,7 @@
  */
 package org.sonar.plugins.python.indexer;
 
-import java.io.File;
-import java.nio.file.Path;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
 import org.sonar.api.batch.sensor.SensorContext;
 import org.sonar.plugins.python.api.caching.CacheContext;
 import org.sonar.python.caching.CacheContextImpl;
@@ -38,105 +35,6 @@ void test_projectLevelTypeTableIsCached() {
     assertThat(typeTable).isInstanceOf(CachedTypeTable.class);
   }
 
-  @Test
-  void test_adjustPackageRoot_noInitPy(@TempDir Path tempDir) {
-    File baseDir = tempDir.toFile();
-    File srcDir = new File(baseDir, "src");
-    srcDir.mkdir();
-
-    String result = PythonIndexer.adjustPackageRoot(srcDir, baseDir);
-    assertThat(result).isEqualTo(srcDir.getAbsolutePath());
-  }
-
-  @Test
-  void test_adjustPackageRoot_withInitPy_walksUp(@TempDir Path tempDir) throws Exception {
-    File baseDir = tempDir.toFile();
-    File srcDir = new File(baseDir, "src");
-    File packageDir = new File(srcDir, "mypackage");
-    packageDir.mkdirs();
-    new File(packageDir, "__init__.py").createNewFile();
-
-    String result = PythonIndexer.adjustPackageRoot(packageDir, baseDir);
-    assertThat(result).isEqualTo(srcDir.getAbsolutePath());
-  }
-
-  @Test
-  void test_adjustPackageRoot_nestedPackagesWithInitPy(@TempDir Path tempDir) throws Exception {
-    File baseDir = tempDir.toFile();
-    File srcDir = new File(baseDir, "src");
-    File level1 = new File(srcDir, "level1");
-    File level2 = new File(level1, "level2");
-    File level3 = new File(level2, "level3");
-    level3.mkdirs();
-
-    new File(level1, "__init__.py").createNewFile();
-    new File(level2, "__init__.py").createNewFile();
-    new File(level3, "__init__.py").createNewFile();
-
-    String result = PythonIndexer.adjustPackageRoot(level3, baseDir);
-    assertThat(result).isEqualTo(srcDir.getAbsolutePath());
-  }
-
-  @Test
-  void test_adjustPackageRoot_stopsAtBaseDir(@TempDir Path tempDir) throws Exception {
-    File baseDir = tempDir.toFile();
-    File level1 = new File(baseDir, "level1");
-    File level2 = new File(level1, "level2");
-    level2.mkdirs();
-    new File(baseDir, "__init__.py").createNewFile();
-    new File(level1, "__init__.py").createNewFile();
-    new File(level2, "__init__.py").createNewFile();
-
-    String result = PythonIndexer.adjustPackageRoot(level2, baseDir);
-    assertThat(result).isEqualTo(baseDir.getAbsolutePath());
-  }
-
-  @Test
-  void test_adjustPackageRoot_rootEqualsBaseDir(@TempDir Path tempDir) throws Exception {
-    File baseDir = tempDir.toFile();
-    new File(baseDir, "__init__.py").createNewFile();
-
-    String result = PythonIndexer.adjustPackageRoot(baseDir, baseDir);
-    assertThat(result).isEqualTo(baseDir.getAbsolutePath());
-  }
-
-  @Test
-  void test_adjustPackageRoot_partialInitPyChain(@TempDir Path tempDir) throws Exception {
-    File baseDir = tempDir.toFile();
-    File srcDir = new File(baseDir, "src");
-    File withInit = new File(srcDir, "withInit");
-    File withoutInit = new File(withInit, "withoutInit");
-    File deepPackage = new File(withoutInit, "deepPackage");
-    deepPackage.mkdirs();
-
-    new File(withInit, "__init__.py").createNewFile();
-    new File(deepPackage, "__init__.py").createNewFile();
-
-    String result = PythonIndexer.adjustPackageRoot(deepPackage, baseDir);
-    assertThat(result).isEqualTo(withoutInit.getAbsolutePath());
-  }
-
-  @Test
-  void test_adjustPackageRoot_emptyDirectory(@TempDir Path tempDir) {
-    File baseDir = tempDir.toFile();
-    File emptyDir = new File(baseDir, "empty");
-    emptyDir.mkdir();
-
-    String result = PythonIndexer.adjustPackageRoot(emptyDir, baseDir);
-    assertThat(result).isEqualTo(emptyDir.getAbsolutePath());
-  }
-
-  @Test
-  void test_adjustPackageRoot_singleLevelWithInitPy(@TempDir Path tempDir) throws Exception {
-    File baseDir = tempDir.toFile();
-    File packageDir = new File(baseDir, "mypackage");
-    packageDir.mkdir();
-    new File(packageDir, "__init__.py").createNewFile();
-
-    String result = PythonIndexer.adjustPackageRoot(packageDir, baseDir);
-    assertThat(result).isEqualTo(baseDir.getAbsolutePath());
-  }
-
   private static class TestPythonIndexer extends PythonIndexer {
 
     protected TestPythonIndexer(ProjectConfigurationBuilder projectConfigurationBuilder) {
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PythonIndexerWrapperTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PythonIndexerWrapperTest.java
index e48f122961..8d58cd2d76 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/PythonIndexerWrapperTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/PythonIndexerWrapperTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/SetupPySourceRootsTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/SetupPySourceRootsTest.java
index 59b3e31942..b16b59a42d 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/SetupPySourceRootsTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/SetupPySourceRootsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/SonarLintPythonIndexerTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/SonarLintPythonIndexerTest.java
index f2e597f761..418e5e9c61 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/SonarLintPythonIndexerTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/SonarLintPythonIndexerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,7 +16,6 @@
  */
 package org.sonar.plugins.python.indexer;
 
-import com.sonar.sslr.api.RecognitionException;
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
@@ -29,10 +28,11 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.api.io.TempDir;
 import org.slf4j.event.Level;
 import org.sonar.api.batch.fs.InputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.plugins.python.Python;
 import org.sonar.plugins.python.PythonInputFile;
@@ -50,11 +50,16 @@
 import org.sonar.python.caching.DummyCache;
 import org.sonar.python.project.config.ProjectConfigurationBuilder;
 import org.sonar.python.semantic.ProjectLevelSymbolTable;
+import org.sonar.scanner.plugin.api.impl.config.MapSettings;
 import org.sonarsource.sonarlint.plugin.api.module.file.ModuleFileEvent;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.clearInvocations;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 class SonarLintPythonIndexerTest {
@@ -179,6 +184,397 @@ void test_indexer_modified_file() {
     assertThat(modAddSymbol).isNotNull();
   }
 
+  @Test
+  void incremental_update_preserves_build_config_roots(@TempDir Path projectDir) throws IOException {
+    Files.createDirectories(projectDir.resolve("src/acme"));
+    Files.writeString(projectDir.resolve("setup.py"), "setup(package_dir={'': 'src'}, packages=['acme'])");
+    PythonInputFile module = inputFile(projectDir, "src/acme/mod.py", "def original():\n    pass\n");
+    var localContext = SensorContextTester.create(projectDir.toFile());
+    localContext.fileSystem().add(module.wrappedFile());
+    var localIndexer = new SonarLintPythonIndexer(
+      new TestModuleFileSystem(new ArrayList<>(List.of(module))), new ProjectConfigurationBuilder());
+
+    localIndexer.buildOnce(localContext);
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.resolve("src").toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("acme.mod.original")).isNotNull();
+
+    PythonInputFile added = inputFile(projectDir, "src/acme/added.py", "def added():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, added));
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.resolve("src").toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("acme.added.added")).isNotNull();
+  }
+
+  @Test
+  void modified_package_configuration_file_refreshes_roots(@TempDir Path projectDir) throws IOException {
+    Path pyproject = projectDir.resolve("pyproject.toml");
+    Files.writeString(pyproject, "[project]\nname = 'before'\n");
+    PythonInputFile module = inputFile(projectDir, "module.py", "def original():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, module));
+
+    String updatedConfig = "[project]\nname = 'after'\n";
+    Files.writeString(pyproject, updatedConfig);
+    InputFile configurationFile = TestInputFileBuilder.create("moduleKey", "pyproject.toml")
+      .setModuleBaseDir(projectDir)
+      .setCharset(StandardCharsets.UTF_8)
+      .setType(InputFile.Type.MAIN)
+      .setLanguage(null)
+      .initMetadata(updatedConfig)
+      .build();
+
+    localIndexer.process(event(ModuleFileEvent.Type.MODIFIED, configurationFile));
+
+    verify(localIndexer).refreshPackageRoots();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.original")).isNotNull();
+  }
+
+  @Test
+  void incremental_init_file_addition_rebuilds_modules_with_new_fqns(@TempDir Path projectDir) throws IOException {
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def foo():\n    pass\n");
+    var localContext = SensorContextTester.create(projectDir.toFile());
+    localContext.fileSystem().add(module.wrappedFile());
+    var localIndexer = spy(new SonarLintPythonIndexer(
+      new TestModuleFileSystem(new ArrayList<>(List.of(module))), new ProjectConfigurationBuilder()));
+    localIndexer.buildOnce(localContext);
+
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.foo")).isNotNull();
+
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, packageInit));
+
+    verify(localIndexer).refreshPackageRoots();
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.foo")).isNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.module.foo")).isNotNull();
+  }
+
+  @Test
+  void incremental_init_file_deletion_rebuilds_modules_with_new_fqns(@TempDir Path projectDir) throws IOException {
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def foo():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, packageInit, module));
+
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.module.foo")).isNotNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.foo")).isNull();
+
+    Files.delete(packageInit.wrappedFile().path());
+
+    localIndexer.process(event(ModuleFileEvent.Type.DELETED, packageInit));
+
+    verify(localIndexer).refreshPackageRoots();
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.resolve("pkg").toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.module.foo")).isNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.foo")).isNotNull();
+  }
+
+  @Test
+  void created_file_under_existing_root_adds_more_specific_legacy_root(@TempDir Path projectDir) throws IOException {
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def original():\n    pass\n");
+    var localIndexer = buildIndexer(projectDir, packageInit, module);
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.toString());
+
+    PythonInputFile script = inputFile(projectDir, "scripts/tool.py", "def run():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, script));
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.resolve("scripts").toString(), projectDir.toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("tool.run")).isNotNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("scripts.tool.run")).isNull();
+  }
+
+  @Test
+  void created_file_with_existing_candidate_root_skips_root_resolution(@TempDir Path projectDir) throws IOException {
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def original():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, packageInit, module));
+
+    PythonInputFile added = inputFile(projectDir, "pkg/added.py", "def added():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, added));
+
+    verify(localIndexer, never()).refreshPackageRoots();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.added.added")).isNotNull();
+  }
+
+  @Test
+  void created_file_in_new_conventional_folder_refreshes_when_candidate_root_is_active(@TempDir Path projectDir) throws IOException {
+    Files.writeString(projectDir.resolve("pyproject.toml"), "[project]\nname = 'sample'\n");
+    PythonInputFile main = inputFile(projectDir, "main.py", "def original():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, main));
+    Files.createDirectories(projectDir.resolve("src"));
+    Files.writeString(projectDir.resolve("src/__init__.py"), "");
+
+    PythonInputFile added = inputFile(projectDir, "src/tool.py", "def run():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, added));
+
+    verify(localIndexer).refreshPackageRoots();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("src.tool.run")).isNotNull();
+  }
+
+  @Test
+  void created_file_covered_by_base_dir_fallback_skips_root_resolution(@TempDir Path projectDir) throws IOException {
+    Files.writeString(projectDir.resolve("pyproject.toml"), "[project]\nname = 'sample'\n");
+    PythonInputFile main = inputFile(projectDir, "main.py", "def original():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, main));
+
+    PythonInputFile added = inputFile(projectDir, "scripts/tool.py", "def run():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, added));
+
+    verify(localIndexer, never()).refreshPackageRoots();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("scripts.tool.run")).isNotNull();
+  }
+
+  @Test
+  void deleted_file_covered_by_base_dir_fallback_skips_root_resolution(@TempDir Path projectDir) throws IOException {
+    Files.writeString(projectDir.resolve("pyproject.toml"), "[project]\nname = 'sample'\n");
+    PythonInputFile first = inputFile(projectDir, "scripts/first.py", "def first():\n    pass\n");
+    PythonInputFile second = inputFile(projectDir, "scripts/second.py", "def second():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, first, second));
+    Files.delete(first.wrappedFile().path());
+
+    localIndexer.process(event(ModuleFileEvent.Type.DELETED, first));
+
+    verify(localIndexer, never()).refreshPackageRoots();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("scripts.first.first")).isNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("scripts.second.second")).isNotNull();
+  }
+
+  @Test
+  void deleted_file_covered_by_configured_root_skips_root_resolution(@TempDir Path projectDir) throws IOException {
+    Files.writeString(projectDir.resolve("setup.py"), "setup(package_dir={'': 'src'}, packages=['acme'])");
+    PythonInputFile module = inputFile(projectDir, "src/acme/module.py", "def original():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, module));
+
+    PythonInputFile added = inputFile(projectDir, "src/acme/added.py", "def added():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, added));
+    clearInvocations(localIndexer);
+    Files.delete(added.wrappedFile().path());
+
+    localIndexer.process(event(ModuleFileEvent.Type.DELETED, added));
+
+    verify(localIndexer, never()).refreshPackageRoots();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("acme.added.added")).isNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("acme.module.original")).isNotNull();
+  }
+
+  @Test
+  void test_file_root_survives_refresh_triggered_by_main_file(@TempDir Path projectDir) throws IOException {
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def original():\n    pass\n");
+    PythonInputFile testFile = inputFile(projectDir, "tests/unit/test_only.py", "def test_something():\n    pass\n", InputFile.Type.TEST);
+    var localIndexer = buildIndexer(projectDir, packageInit, module, testFile);
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.resolve("tests/unit").toString(), projectDir.toString());
+    assertThat(localIndexer.getFileWithId(testFile.wrappedFile().absolutePath())).isNull();
+
+    PythonInputFile script = inputFile(projectDir, "scripts/tool.py", "def run():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, script));
+
+    assertThat(localIndexer.packageRoots()).containsExactly(
+      projectDir.resolve("tests/unit").toString(),
+      projectDir.resolve("scripts").toString(),
+      projectDir.toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.module.original")).isNotNull();
+    assertThat(localIndexer.getFileWithId(testFile.wrappedFile().absolutePath())).isNull();
+  }
+
+  @Test
+  void created_test_file_updates_roots_without_entering_project_index(@TempDir Path projectDir) throws IOException {
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def original():\n    pass\n");
+    var localIndexer = buildIndexer(projectDir, packageInit, module);
+
+    PythonInputFile testFile = inputFile(projectDir, "tests/unit/test_only.py", "def test_something():\n    pass\n", InputFile.Type.TEST);
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, testFile));
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.resolve("tests/unit").toString(), projectDir.toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.module.original")).isNotNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("test_only.test_something")).isNull();
+    assertThat(localIndexer.getFileWithId(testFile.wrappedFile().absolutePath())).isNull();
+  }
+
+  @Test
+  void deleted_test_file_removes_its_root_without_affecting_main_index(@TempDir Path projectDir) throws IOException {
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def original():\n    pass\n");
+    PythonInputFile testFile = inputFile(projectDir, "tests/unit/test_only.py", "def test_something():\n    pass\n", InputFile.Type.TEST);
+    var localIndexer = buildIndexer(projectDir, packageInit, module, testFile);
+
+    localIndexer.process(event(ModuleFileEvent.Type.DELETED, testFile));
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.module.original")).isNotNull();
+    assertThat(localIndexer.getFileWithId(testFile.wrappedFile().absolutePath())).isNull();
+  }
+
+  @Test
+  void deleted_file_with_another_root_contributor_skips_root_resolution(@TempDir Path projectDir) throws IOException {
+    PythonInputFile first = inputFile(projectDir, "scripts/first.py", "def first():\n    pass\n");
+    PythonInputFile second = inputFile(projectDir, "scripts/second.py", "def second():\n    pass\n");
+    PythonInputFile third = inputFile(projectDir, "scripts/third.py", "def third():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, first, second, third));
+
+    localIndexer.process(event(ModuleFileEvent.Type.DELETED, first));
+    clearInvocations(localIndexer);
+    localIndexer.process(event(ModuleFileEvent.Type.DELETED, second));
+
+    verify(localIndexer, never()).refreshPackageRoots();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("first.first")).isNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("second.second")).isNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("third.third")).isNotNull();
+  }
+
+  @Test
+  void modified_main_file_reclassified_as_test_is_removed_from_project_index(@TempDir Path projectDir) throws IOException {
+    PythonInputFile mainFile = inputFile(projectDir, "module.py", "def original():\n    pass\n");
+    var localIndexer = buildIndexer(projectDir, mainFile);
+
+    PythonInputFile testFile = inputFile(projectDir, "module.py", "def test_something():\n    pass\n", InputFile.Type.TEST);
+    localIndexer.process(event(ModuleFileEvent.Type.MODIFIED, testFile));
+
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.original")).isNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.test_something")).isNull();
+    assertThat(localIndexer.getFileWithId(testFile.wrappedFile().absolutePath())).isNull();
+  }
+
+  @Test
+  void modified_test_file_reclassified_as_main_is_added_to_project_index(@TempDir Path projectDir) throws IOException {
+    PythonInputFile testFile = inputFile(projectDir, "module.py", "def test_something():\n    pass\n", InputFile.Type.TEST);
+    var localIndexer = buildIndexer(projectDir, testFile);
+
+    PythonInputFile mainFile = inputFile(projectDir, "module.py", "def production():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.MODIFIED, mainFile));
+
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.production")).isNotNull();
+    assertThat(localIndexer.getFileWithId(mainFile.wrappedFile().absolutePath())).isSameAs(mainFile.wrappedFile());
+  }
+
+  @Test
+  void deleted_file_removes_legacy_root_and_rebuilds_remaining_modules(@TempDir Path projectDir) throws IOException {
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def original():\n    pass\n");
+    PythonInputFile script = inputFile(projectDir, "scripts/tool.py", "def run():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, packageInit, module, script));
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.resolve("scripts").toString(), projectDir.toString());
+
+    localIndexer.process(event(ModuleFileEvent.Type.DELETED, script));
+
+    verify(localIndexer).refreshPackageRoots();
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("tool.run")).isNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.module.original")).isNotNull();
+  }
+
+  @Test
+  void deleted_file_with_removed_conventional_directory_refreshes_roots(@TempDir Path projectDir) throws IOException {
+    Files.writeString(projectDir.resolve("pyproject.toml"), "[project]\nname = 'sample'\n");
+    PythonInputFile script = inputFile(projectDir, "src/scripts/tool.py", "def run():\n    pass\n");
+    var localIndexer = spy(buildIndexer(projectDir, script));
+    Files.delete(script.wrappedFile().path());
+    Files.delete(projectDir.resolve("src/scripts"));
+    Files.delete(projectDir.resolve("src"));
+
+    localIndexer.process(event(ModuleFileEvent.Type.DELETED, script));
+
+    verify(localIndexer).refreshPackageRoots();
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.toString());
+  }
+
+  @Test
+  void created_src_folder_switches_from_base_dir_to_conventional_roots(@TempDir Path projectDir) throws IOException {
+    Files.writeString(projectDir.resolve("pyproject.toml"), "[project]\nname = 'sample'\n");
+    PythonInputFile main = inputFile(projectDir, "main.py", "def original():\n    pass\n");
+    var localIndexer = buildIndexer(projectDir, main);
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.toString());
+
+    PythonInputFile source = inputFile(projectDir, "src/tool.py", "def run():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, source));
+
+    assertThat(localIndexer.packageRoots()).containsExactly(projectDir.resolve("src").toString(), projectDir.toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("tool.run")).isNotNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("src.tool.run")).isNull();
+  }
+
+  @Test
+  void rebuild_continues_after_invalid_python_and_keeps_it_for_root_resolution(@TempDir Path projectDir) throws IOException {
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def original():\n    pass\n");
+    PythonInputFile invalid = inputFile(projectDir, "broken/invalid.py", "foo(");
+    var localIndexer = buildIndexer(projectDir, packageInit, module, invalid);
+
+    assertThat(localIndexer.getFileWithId(invalid.wrappedFile().absolutePath())).isNull();
+
+    PythonInputFile script = inputFile(projectDir, "scripts/tool.py", "def run():\n    pass\n");
+    assertDoesNotThrow(() -> localIndexer.process(event(ModuleFileEvent.Type.CREATED, script)));
+
+    assertThat(localIndexer.packageRoots()).containsExactly(
+      projectDir.resolve("broken").toString(),
+      projectDir.resolve("scripts").toString(),
+      projectDir.toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.module.original")).isNotNull();
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("tool.run")).isNotNull();
+    assertThat(localIndexer.getFileWithId(invalid.wrappedFile().absolutePath())).isNull();
+  }
+
+  @Test
+  void modified_file_can_be_temporarily_invalid_and_recover(@TempDir Path projectDir) throws IOException {
+    PythonInputFile original = inputFile(projectDir, "module.py", "def original():\n    pass\n");
+    var localIndexer = buildIndexer(projectDir, original);
+
+    PythonInputFile invalid = inputFile(projectDir, "module.py", "foo(");
+    assertDoesNotThrow(() -> localIndexer.process(event(ModuleFileEvent.Type.MODIFIED, invalid)));
+
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.original")).isNull();
+    assertThat(localIndexer.getFileWithId(invalid.wrappedFile().absolutePath())).isNull();
+
+    PythonInputFile recovered = inputFile(projectDir, "module.py", "def recovered():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.MODIFIED, recovered));
+
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("module.recovered")).isNotNull();
+    assertThat(localIndexer.getFileWithId(recovered.wrappedFile().absolutePath())).isSameAs(recovered.wrappedFile());
+  }
+
+  @Test
+  void rebuild_keeps_unreadable_file_for_root_resolution(@TempDir Path projectDir) throws IOException {
+    PythonInputFile packageInit = inputFile(projectDir, "pkg/__init__.py", "");
+    PythonInputFile module = inputFile(projectDir, "pkg/module.py", "def original():\n    pass\n");
+    PythonInputFile readableInput = inputFile(projectDir, "unreadable/module.py", "def ignored():\n    pass\n");
+    InputFile unreadableFile = spy(readableInput.wrappedFile());
+    when(unreadableFile.contents()).thenThrow(new IOException("not readable"));
+    PythonInputFile unreadableInput = new PythonInputFileImpl(unreadableFile);
+    var localIndexer = buildIndexer(projectDir, packageInit, module, unreadableInput);
+
+    PythonInputFile script = inputFile(projectDir, "scripts/tool.py", "def run():\n    pass\n");
+    assertDoesNotThrow(() -> localIndexer.process(event(ModuleFileEvent.Type.CREATED, script)));
+
+    assertThat(localIndexer.packageRoots()).containsExactly(
+      projectDir.resolve("scripts").toString(),
+      projectDir.resolve("unreadable").toString(),
+      projectDir.toString());
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("pkg.module.original")).isNotNull();
+    assertThat(localIndexer.getFileWithId(unreadableFile.absolutePath())).isNull();
+  }
+
+  @Test
+  void project_over_line_limit_does_not_partially_activate_after_file_event(@TempDir Path projectDir) throws IOException {
+    PythonInputFile module = inputFile(projectDir, "module.py", "def original():\n    pass\n");
+    var localContext = SensorContextTester.create(projectDir.toFile());
+    localContext.setSettings(new MapSettings().setProperty("sonar.python.sonarlint.indexing.maxlines", 1));
+    localContext.fileSystem().add(module.wrappedFile());
+    var localIndexer = new SonarLintPythonIndexer(
+      new TestModuleFileSystem(new ArrayList<>(List.of(module))), new ProjectConfigurationBuilder());
+    localIndexer.buildOnce(localContext);
+
+    PythonInputFile added = inputFile(projectDir, "scripts/tool.py", "def run():\n    pass\n");
+    localIndexer.process(event(ModuleFileEvent.Type.CREATED, added));
+
+    assertThat(localIndexer.projectLevelSymbolTable().getSymbol("tool.run")).isNull();
+    assertThat(localIndexer.getFileWithId(added.wrappedFile().absolutePath())).isNull();
+  }
+
   @Test
   void test_indexer_non_python_file() {
     testNonPythonFile("txt");
@@ -279,11 +675,7 @@ private void testNonPythonFile(@Nullable String language) {
     ModuleFileEvent moduleFileEvent = mock(ModuleFileEvent.class);
     PythonInputFile txtFile = createInputFile("non_python.txt", language);
     when(moduleFileEvent.getTarget()).thenReturn(txtFile.wrappedFile());
-    try {
-      pythonIndexer.process(moduleFileEvent);
-    } catch (RecognitionException exception) {
-      fail("Non Python files should not be parsed.");
-    }
+    assertDoesNotThrow(() -> pythonIndexer.process(moduleFileEvent), "Non Python files should not be parsed.");
     assertThat(logTester.logs(Level.DEBUG)).contains("Module file event for non_python.txt has been ignored because it's not a Python file.");
     assertThat(projectLevelSymbolTable.getSymbolsFromModule("non_python")).isNull();
   }
@@ -307,4 +699,41 @@ private PythonInputFile createInputFile(String name, String languageKey) {
       .initMetadata(TestUtils.fileContent(new File(baseDir, name), StandardCharsets.UTF_8))
       .build());
   }
+
+  private static PythonInputFile inputFile(Path projectDir, String relativePath, String content) throws IOException {
+    return inputFile(projectDir, relativePath, content, InputFile.Type.MAIN);
+  }
+
+  private static PythonInputFile inputFile(Path projectDir, String relativePath, String content, InputFile.Type type) throws IOException {
+    Path path = projectDir.resolve(relativePath);
+    Files.createDirectories(path.getParent());
+    Files.writeString(path, content);
+    return new PythonInputFileImpl(TestInputFileBuilder.create("moduleKey", relativePath)
+      .setModuleBaseDir(projectDir)
+      .setCharset(StandardCharsets.UTF_8)
+      .setType(type)
+      .setLanguage(Python.KEY)
+      .initMetadata(content)
+      .build());
+  }
+
+  private static ModuleFileEvent event(ModuleFileEvent.Type type, PythonInputFile inputFile) {
+    return event(type, inputFile.wrappedFile());
+  }
+
+  private static ModuleFileEvent event(ModuleFileEvent.Type type, InputFile inputFile) {
+    ModuleFileEvent event = mock(ModuleFileEvent.class);
+    when(event.getType()).thenReturn(type);
+    when(event.getTarget()).thenReturn(inputFile);
+    return event;
+  }
+
+  private static SonarLintPythonIndexer buildIndexer(Path projectDir, PythonInputFile... files) {
+    var localContext = SensorContextTester.create(projectDir.toFile());
+    Arrays.stream(files).map(PythonInputFile::wrappedFile).forEach(localContext.fileSystem()::add);
+    var localIndexer = new SonarLintPythonIndexer(
+      new TestModuleFileSystem(new ArrayList<>(Arrays.asList(files))), new ProjectConfigurationBuilder());
+    localIndexer.buildOnce(localContext);
+    return localIndexer;
+  }
 }
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/SonarQubePythonIndexerTest.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/SonarQubePythonIndexerTest.java
index 54da23334b..4b619a0279 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/SonarQubePythonIndexerTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/SonarQubePythonIndexerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -33,7 +33,7 @@
 import org.slf4j.event.Level;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.sensor.SensorContext;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.plugins.python.PythonInputFile;
 import org.sonar.plugins.python.api.caching.PythonReadCache;
@@ -43,6 +43,7 @@
 import org.sonar.python.caching.CacheContextImpl;
 import org.sonar.python.caching.PythonReadCacheImpl;
 import org.sonar.python.caching.PythonWriteCacheImpl;
+import org.sonar.python.index.Descriptor;
 import org.sonar.python.index.VariableDescriptor;
 import org.sonar.python.project.config.ProjectConfigurationBuilder;
 import org.sonar.python.types.TypeShed;
@@ -54,6 +55,7 @@
 import static org.sonar.plugins.python.TestUtils.createInputFile;
 import static org.sonar.plugins.python.caching.Caching.CACHE_VERSION_KEY;
 import static org.sonar.plugins.python.caching.Caching.PROJECT_FILES_KEY;
+import static org.sonar.plugins.python.caching.Caching.TEST_SOURCES_CONFIGURED_KEY;
 import static org.sonar.plugins.python.caching.Caching.TYPESHED_MODULES_KEY;
 import static org.sonar.plugins.python.caching.Caching.fileContentHashCacheKey;
 import static org.sonar.plugins.python.caching.Caching.importsMapCacheKey;
@@ -90,6 +92,7 @@ void init() throws IOException {
     writeCache.bind(readCache);
     cacheVersion = "unknownPluginVersion";
     readCache.put(CACHE_VERSION_KEY, cacheVersion.getBytes(StandardCharsets.UTF_8));
+    readCache.put(TEST_SOURCES_CONFIGURED_KEY, "false".getBytes(StandardCharsets.UTF_8));
     PythonWriteCache pythonWriteCache = new PythonWriteCacheImpl(writeCache);
     PythonReadCache pythonReadCache = new PythonReadCacheImpl(readCache);
     cacheContext = new CacheContextImpl(true, pythonWriteCache, pythonReadCache);
@@ -513,10 +516,6 @@ void test_package_roots_from_pyproject_toml_setuptools() throws IOException {
     tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
     tempContext.settings().setProperty("sonar.python.skipUnchanged", false);
 
-    // Add pyproject.toml as input file so it can be found
-    PythonInputFile pyprojectFile = createInputFile(tempDir.toFile(), "pyproject.toml", InputFile.Status.SAME, InputFile.Type.MAIN);
-    tempContext.fileSystem().add(pyprojectFile.wrappedFile());
-
     PythonInputFile meanFile = createInputFile(srcDir.toFile(),
       "mean.py",
       InputFile.Status.ADDED, InputFile.Type.MAIN);
@@ -536,11 +535,12 @@ void test_package_roots_from_pyproject_toml_setuptools() throws IOException {
   @Test
   void test_package_roots_fallback_to_src_folder() throws IOException {
     // Create a temp directory with src folder but no pyproject.toml
-    Path tempDir = Files.createTempDirectory("src_fallback_test");
+    Path tempDir = Files.createTempDirectory("src_fallback_test").toRealPath();
     Path srcDir = tempDir.resolve(Path.of("src", "mypackage"));
     Files.createDirectories(srcDir);
     Files.writeString(srcDir.resolve("__init__.py"), "");
     Files.writeString(srcDir.resolve("module.py"), "x = 1");
+    Files.writeString(tempDir.resolve("pyproject.toml"), "");
 
     SensorContextTester tempContext = SensorContextTester.create(tempDir.toFile());
     tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
@@ -569,10 +569,11 @@ void test_package_roots_fallback_to_src_folder() throws IOException {
   @Test
   void test_package_roots_fallback_to_base_dir() throws IOException {
     // Create a temp directory without src folder or pyproject.toml
-    Path tempDir = Files.createTempDirectory("basedir_fallback_test");
+    Path tempDir = Files.createTempDirectory("basedir_fallback_test").toRealPath();
     Path pkgDir = Files.createDirectories(tempDir.resolve("mypackage"));
     Files.writeString(pkgDir.resolve("__init__.py"), "");
     Files.writeString(pkgDir.resolve("module.py"), "x = 1");
+    Files.writeString(tempDir.resolve("pyproject.toml"), "");
 
     SensorContextTester tempContext = SensorContextTester.create(tempDir.toFile());
     tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
@@ -596,11 +597,42 @@ void test_package_roots_fallback_to_base_dir() throws IOException {
     assertThat(packageName).isEqualTo("mypackage");
   }
 
+  @Test
+  void test_package_roots_from_sonar_sources_dot() throws IOException {
+    // sonar.sources=. means "scan from the project root" — must resolve to baseDir, not "/baseDir/."
+    Path tempDir = Files.createTempDirectory("sonar_sources_dot_test").toRealPath();
+    Path pkgDir = Files.createDirectories(tempDir.resolve("mypackage"));
+    Files.writeString(pkgDir.resolve("module.py"), "x = 1");
+    Files.writeString(tempDir.resolve("pyproject.toml"), "");
+
+    SensorContextTester tempContext = SensorContextTester.create(tempDir.toFile());
+    tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
+    tempContext.settings().setProperty("sonar.python.skipUnchanged", false);
+    tempContext.settings().setProperty("sonar.sources", ".");
+
+    PythonInputFile moduleFile = createInputFile(tempDir.toFile(),
+      "mypackage/module.py",
+      InputFile.Status.ADDED, InputFile.Type.MAIN);
+    List inputFiles = List.of(moduleFile);
+
+    CacheContextImpl noCacheContext = new CacheContextImpl(false, new PythonWriteCacheImpl(new TestWriteCache()), new PythonReadCacheImpl(new TestReadCache()));
+    SonarQubePythonIndexer indexer = new SonarQubePythonIndexer(inputFiles, noCacheContext, tempContext, new ProjectConfigurationBuilder());
+
+    // Package root must be the base dir, not the un-normalized "/baseDir/."
+    String expectedRoot = tempDir.toFile().getAbsolutePath();
+    assertThat(indexer.packageRoots()).containsExactly(expectedRoot);
+
+    // FQN should be computed correctly using the base dir as root
+    String packageName = indexer.packageName(moduleFile);
+    assertThat(packageName).isEqualTo("mypackage");
+  }
+
   @Test
   void test_package_roots_from_sonar_sources() throws IOException {
     // Create a temp directory with custom sources folder
-    Path tempDir = Files.createTempDirectory("sonar_sources_test");
-    Path libDir = tempDir.resolve(Path.of("lib", "mylib"));
+    Path tempDir = Files.createTempDirectory("sonar_sources_test").toRealPath();
+    Files.writeString(tempDir.resolve("pyproject.toml"), "");
+    Path libDir = tempDir.resolve(Path.of("some_lib", "mylib"));
     Files.createDirectories(libDir);
     Files.writeString(libDir.resolve("__init__.py"), "");
     Files.writeString(libDir.resolve("utils.py"), "x = 1");
@@ -608,10 +640,10 @@ void test_package_roots_from_sonar_sources() throws IOException {
     SensorContextTester tempContext = SensorContextTester.create(tempDir.toFile());
     tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
     tempContext.settings().setProperty("sonar.python.skipUnchanged", false);
-    tempContext.settings().setProperty("sonar.sources", "lib");
+    tempContext.settings().setProperty("sonar.sources", "some_lib");
 
     PythonInputFile utilsFile = createInputFile(tempDir.toFile(),
-      "lib/mylib/utils.py",
+      "some_lib/mylib/utils.py",
       InputFile.Status.ADDED, InputFile.Type.MAIN);
     List inputFiles = List.of(utilsFile);
 
@@ -620,7 +652,7 @@ void test_package_roots_from_sonar_sources() throws IOException {
 
     // Package roots should come from sonar.sources
     // Use File.getAbsolutePath() for both sides to ensure consistent path representation on Windows
-    String expectedRoot = new File(tempDir.toFile(), "lib").getAbsolutePath();
+    String expectedRoot = new File(tempDir.toFile(), "some_lib").getAbsolutePath();
     assertThat(indexer.packageRoots()).containsExactly(expectedRoot);
 
     // FQN should be computed correctly
@@ -647,10 +679,6 @@ void test_package_roots_from_setup_py() throws IOException {
     tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
     tempContext.settings().setProperty("sonar.python.skipUnchanged", false);
 
-    // Add setup.py as input file so it can be found
-    PythonInputFile setupPyFile = createInputFile(tempDir.toFile(), "setup.py", InputFile.Status.SAME, InputFile.Type.MAIN);
-    tempContext.fileSystem().add(setupPyFile.wrappedFile());
-
     PythonInputFile meanFile = createInputFile(tempDir.toFile(),
       Path.of("src", "acme", "math", "stats", "mean.py").toString(),
       InputFile.Status.ADDED, InputFile.Type.MAIN);
@@ -696,12 +724,6 @@ void test_package_roots_from_both_pyproject_and_setup_py() throws IOException {
     tempContext.fileSystem().setWorkDir(Files.createTempDirectory("workDir"));
     tempContext.settings().setProperty("sonar.python.skipUnchanged", false);
 
-    // Add both config files
-    PythonInputFile pyprojectFile = createInputFile(tempDir.toFile(), "pyproject.toml", InputFile.Status.SAME, InputFile.Type.MAIN);
-    PythonInputFile setupPyFile = createInputFile(tempDir.toFile(), "setup.py", InputFile.Status.SAME, InputFile.Type.MAIN);
-    tempContext.fileSystem().add(pyprojectFile.wrappedFile());
-    tempContext.fileSystem().add(setupPyFile.wrappedFile());
-
     PythonInputFile moduleFile = createInputFile(tempDir.toFile(),
       Path.of("src", "mypackage", "module.py").toString(),
       InputFile.Status.ADDED, InputFile.Type.MAIN);
@@ -722,4 +744,34 @@ void test_package_roots_from_both_pyproject_and_setup_py() throws IOException {
     assertThat(indexer.packageName(moduleFile)).isEqualTo("mypackage");
     assertThat(indexer.packageName(utilsFile)).isEqualTo("otherpackage");
   }
+
+  @Test
+  void test_cached_descriptors_accessible_by_module_fqn() {
+    // Both files unchanged — triggers the optimized cache path
+    file1 = createInputFile(baseDir, "main.py", InputFile.Status.SAME, InputFile.Type.MAIN);
+    file2 = createInputFile(baseDir, "mod.py", InputFile.Status.SAME, InputFile.Type.MAIN);
+
+    List inputFiles = new ArrayList<>(Arrays.asList(file1, file2));
+
+    VariableDescriptor modDescriptor = new VariableDescriptor("add", "mod.add", null);
+    byte[] serializedMain = toProtobufModuleDescriptor(Set.of(new VariableDescriptor("x", "main.x", null))).toByteArray();
+    byte[] serializedMod = toProtobufModuleDescriptor(Set.of(modDescriptor)).toByteArray();
+
+    readCache.put(importsMapCacheKey("moduleKey:main.py"), importsAsByteArray(List.of("mod")));
+    readCache.put(importsMapCacheKey("moduleKey:mod.py"), importsAsByteArray(Collections.emptyList()));
+    readCache.put(projectSymbolTableCacheKey("moduleKey:main.py"), serializedMain);
+    readCache.put(projectSymbolTableCacheKey("moduleKey:mod.py"), serializedMod);
+    readCache.put(fileContentHashCacheKey("moduleKey:main.py"), file1.wrappedFile().md5Hash().getBytes(StandardCharsets.UTF_8));
+    readCache.put(fileContentHashCacheKey("moduleKey:mod.py"), file2.wrappedFile().md5Hash().getBytes(StandardCharsets.UTF_8));
+
+    pythonIndexer = new SonarQubePythonIndexer(inputFiles, cacheContext, context, new ProjectConfigurationBuilder());
+    pythonIndexer.buildOnce(context);
+
+    // Confirm the optimized cache path was taken for mod.py
+    assertThat(pythonIndexer.canBePartiallyScannedWithoutParsing(file2)).isTrue();
+
+    Set descriptors = pythonIndexer.projectLevelSymbolTable().getDescriptorsFromModule("mod");
+    assertThat(descriptors).isNotNull();
+    assertThat(descriptors).extracting(Descriptor::name).containsExactly("add");
+  }
 }
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/indexer/TestModuleFileSystem.java b/python-commons/src/test/java/org/sonar/plugins/python/indexer/TestModuleFileSystem.java
index 7d94cbfe13..70ba1b6010 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/indexer/TestModuleFileSystem.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/indexer/TestModuleFileSystem.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -31,8 +31,10 @@ public TestModuleFileSystem(List inputFiles) {
   }
 
   @Override
-  public Stream files(String s, InputFile.Type type) {
-    return inputFiles.stream().map(PythonInputFile::wrappedFile);
+  public Stream files(String language, InputFile.Type type) {
+    return files()
+      .filter(file -> language.equals(file.language()))
+      .filter(file -> type == file.type());
   }
 
   @Override
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/mypy/MypyRulesDefinitionTest.java b/python-commons/src/test/java/org/sonar/plugins/python/mypy/MypyRulesDefinitionTest.java
index 3c40c191eb..bfd38277e6 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/mypy/MypyRulesDefinitionTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/mypy/MypyRulesDefinitionTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/mypy/MypySensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/mypy/MypySensorTest.java
index 891f4c98ca..e9fdf97eae 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/mypy/MypySensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/mypy/MypySensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,9 @@
  */
 package org.sonar.plugins.python.mypy;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -32,16 +35,13 @@
 import org.sonar.api.SonarRuntime;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.TextRange;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.rule.Severity;
-import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
 import org.sonar.api.batch.sensor.issue.ExternalIssue;
 import org.sonar.api.batch.sensor.issue.IssueLocation;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.rules.RuleType;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.api.utils.Version;
+import org.sonar.scanner.plugin.api.impl.sensor.DefaultSensorDescriptor;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -53,7 +53,7 @@ class MypySensorTest {
   private static final String UNKNOWN_FILE_REPORT = "mypy_unknown_file_output.txt";
 
   private static final MypySensor mypySensor = new MypySensor();
-  private static final SonarRuntime SONAR_RUNTIME = SonarRuntimeImpl.forSonarQube(Version.create(9, 9), SonarQubeSide.SERVER, SonarEdition.DEVELOPER);
+  private static final SonarRuntime SONAR_RUNTIME = TestSonarRuntime.forSonarQube(Version.create(9, 9), SonarQubeSide.SERVER, SonarEdition.DEVELOPER);
 
   @RegisterExtension
   public LogTesterJUnit5 logTester = new LogTesterJUnit5().setLevel(Level.DEBUG);
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/nosonar/NoSonarIssueFilterTest.java b/python-commons/src/test/java/org/sonar/plugins/python/nosonar/NoSonarIssueFilterTest.java
index 133453ffe1..c792e2be37 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/nosonar/NoSonarIssueFilterTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/nosonar/NoSonarIssueFilterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -24,32 +24,37 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mockito;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.api.scan.issue.filter.FilterableIssue;
 import org.sonar.api.scan.issue.filter.IssueFilterChain;
 import org.sonar.plugins.python.api.nosonar.NoSonarLineInfo;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
 class NoSonarIssueFilterTest {
-  
+
+  private static final Set SECURITY_RULES = Set.of("S4423");
+
   @ParameterizedTest
   @MethodSource("provideFilterParameters")
   void test(Map noSonarInfos, String ruleKey, @Nullable Integer line, boolean filterChainAcceptResult, boolean expectedResult) {
     var componentKey = "foo.py";
     var ruleRepo = "my_repo";
 
-    var collector = Mockito.mock(NoSonarLineInfoCollector.class);
-    Mockito.when(collector.get(componentKey))
+    var collector = mock(NoSonarLineInfoCollector.class);
+    when(collector.get(componentKey))
       .thenReturn(noSonarInfos);
-    var filter = new NoSonarIssueFilter(collector);
 
-    var issue = Mockito.mock(FilterableIssue.class);
-    Mockito.when(issue.componentKey()).thenReturn(componentKey);
-    Mockito.when(issue.line()).thenReturn(line);
-    Mockito.when(issue.ruleKey()).thenReturn(RuleKey.of(ruleRepo, ruleKey));
+    var filter = new NoSonarIssueFilter(collector, new SecurityRuleKeyProvider(SECURITY_RULES));
 
-    var filterChain = Mockito.mock(IssueFilterChain.class);
-    Mockito.when(filterChain.accept(issue)).thenReturn(filterChainAcceptResult);
+    var issue = mock(FilterableIssue.class);
+    when(issue.componentKey()).thenReturn(componentKey);
+    when(issue.line()).thenReturn(line);
+    when(issue.ruleKey()).thenReturn(RuleKey.of(ruleRepo, ruleKey));
+
+    var filterChain = mock(IssueFilterChain.class);
+    when(filterChain.accept(issue)).thenReturn(filterChainAcceptResult);
 
     var result = filter.accept(issue, filterChain);
     Assertions.assertThat(result)
@@ -58,17 +63,50 @@ void test(Map noSonarInfos, String ruleKey, @Nullable
   }
 
   private static Stream provideFilterParameters() {
+    return Stream.concat(
+      provideBaseFilterParameters(),
+      provideSecurityOnlySuppressionParameters()
+    );
+  }
+
+  private static Stream provideBaseFilterParameters() {
     return Stream.of(
+      // explicit key suppression: suppress matching rule
       Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of("my_rule"))), "my_rule", 1, true, false),
+      // bare NOSONAR/noqa (securityOnlySuppression=false): suppress all
       Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of())), "my_rule", 1, true, false),
       Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of())), "my_rule", 1, false, false),
+      // explicit key suppression: different rule, not suppressed
       Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of("other_rule"))), "my_rule", 1, true, true),
+      // suppression on different line: not suppressed
       Arguments.of(Map.of(2, new NoSonarLineInfo(Set.of("my_rule"))), "my_rule", 1, true, true),
+      // issue has no line: never suppressed
       Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of("my_rule"))), "my_rule", null, true, true),
+      // different rule on same line with chain rejecting: chain result propagates
       Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of("other_rule"))), "my_rule", 1, false, false),
+      // S1309 is whitelisted — never suppressed by explicit key
       Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of("S1309"))), "S1309", 1, true, true),
       Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of("S1309"))), "S1309", 1, false, false),
+      // no suppression comment: chain decides
       Arguments.of(Map.of(), "my_rule", 1, false, false)
     );
   }
+
+  private static Stream provideSecurityOnlySuppressionParameters() {
+    return Stream.of(
+      // bare nosec: suppresses security rule S4423
+      Arguments.of(Map.of(1, NoSonarLineInfo.securityOnly()), "S4423", 1, true, false),
+      // bare nosec: does NOT suppress non-security rule
+      Arguments.of(Map.of(1, NoSonarLineInfo.securityOnly()), "my_rule", 1, true, true),
+      // bare nosec: S1309 is whitelisted, chain decides regardless
+      Arguments.of(Map.of(1, NoSonarLineInfo.securityOnly()), "S1309", 1, true, true),
+      Arguments.of(Map.of(1, NoSonarLineInfo.securityOnly()), "S1309", 1, false, false),
+      // mixed: explicit key + nosec — explicit key is suppressed
+      Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of("E501"), "", true)), "E501", 1, true, false),
+      // mixed: explicit key + nosec — security rule is also suppressed
+      Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of("E501"), "", true)), "S4423", 1, true, false),
+      // mixed: explicit key + nosec — non-security rule not in keys is NOT suppressed
+      Arguments.of(Map.of(1, new NoSonarLineInfo(Set.of("E501"), "", true)), "my_rule", 1, true, true)
+    );
+  }
 }
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/nosonar/NoSonarLineInfoCollectorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/nosonar/NoSonarLineInfoCollectorTest.java
index 5a5f118101..7fc6701795 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/nosonar/NoSonarLineInfoCollectorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/nosonar/NoSonarLineInfoCollectorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -185,6 +185,33 @@ private static Stream provideCollectorParameters() {
         Set.of(1, 2, 3, 4, 5),
         "",
         ""
+      ),
+      Arguments.of("""
+          import hashlib
+          hashlib.md5(b"x").hexdigest() # nosec
+          """,
+        Map.of(2, new NoSonarLineInfo(Set.of(), "", true)),
+        Set.of(2),
+        "",
+        ""
+      ),
+      Arguments.of("""
+          import hashlib
+          hashlib.md5(b"x").hexdigest() # nosec B303 legacy hash
+          """,
+        Map.of(2, new NoSonarLineInfo(Set.of("B303"))),
+        Set.of(),
+        "B303",
+        "B303:"
+      ),
+      Arguments.of("""
+          import ssl
+          ssl.SSLContext(ssl.PROTOCOL_TLSv1) # nosec S4423
+          """,
+        Map.of(2, new NoSonarLineInfo(Set.of("S4423"))),
+        Set.of(),
+        "S4423",
+        "S4423:"
       )
     );
   }
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/nosonar/SecurityRuleKeyProviderTest.java b/python-commons/src/test/java/org/sonar/plugins/python/nosonar/SecurityRuleKeyProviderTest.java
new file mode 100644
index 0000000000..f90a905019
--- /dev/null
+++ b/python-commons/src/test/java/org/sonar/plugins/python/nosonar/SecurityRuleKeyProviderTest.java
@@ -0,0 +1,169 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.nosonar;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Map;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class SecurityRuleKeyProviderTest {
+
+  @Test
+  void test_loads_vulnerability_as_security() {
+    var provider = new SecurityRuleKeyProvider();
+    Assertions.assertThat(provider.isSecurityRule("TestVulnerability")).isTrue();
+  }
+
+  @Test
+  void test_code_smell_is_not_security() {
+    var provider = new SecurityRuleKeyProvider();
+    Assertions.assertThat(provider.isSecurityRule("TestCodeSmell")).isFalse();
+  }
+
+  @Test
+  void test_unknown_rule_is_not_security() {
+    var provider = new SecurityRuleKeyProvider();
+    Assertions.assertThat(provider.isSecurityRule("S9999")).isFalse();
+    Assertions.assertThat(provider.isSecurityRule("NonExistentRule")).isFalse();
+  }
+
+  @Test
+  void test_json_without_type_field_and_malformed_json_are_not_security() {
+    var provider = new SecurityRuleKeyProvider();
+    Assertions.assertThat(provider.isSecurityRule("TestNoType")).isFalse();
+    Assertions.assertThat(provider.isSecurityRule("TestMalformedJson")).isFalse();
+  }
+
+  @Test
+  void test_jar_url_with_null_entry_name_is_skipped() throws Exception {
+    var jarPath = createTempJar(Map.of(
+      "org/sonar/l10n/py/rules/python/", "",
+      "org/sonar/l10n/py/rules/python/JarVuln.json", "{\"type\": \"VULNERABILITY\"}"
+    ));
+    try {
+      // "jar:...!/" with nothing after the separator gives getEntryName() == null
+      var noEntryUrl = new URL("jar:" + jarPath.toUri() + "!/");
+      ClassLoader loader = new ClassLoader(null) {
+        @Override
+        public Enumeration getResources(String name) {
+          return Collections.enumeration(List.of(noEntryUrl));
+        }
+      };
+      var provider = new SecurityRuleKeyProvider(loader);
+      Assertions.assertThat(provider.isSecurityRule("JarVuln")).isFalse();
+    } finally {
+      Files.deleteIfExists(jarPath);
+    }
+  }
+
+  @Test
+  void test_jar_without_directory_entry_yields_no_keys() throws Exception {
+    // JARs without an explicit directory entry for the rule path are not discovered —
+    // ClassLoader.getResources("dir/") requires a matching directory entry in the JAR.
+    var jarPath = createTempJar(Map.of(
+      "org/sonar/l10n/py/rules/python/JarVulnerability.json", "{\"type\": \"VULNERABILITY\"}"
+    ));
+    try {
+      try (var jarClassLoader = new URLClassLoader(new URL[]{jarPath.toUri().toURL()}, null)) {
+        var provider = new SecurityRuleKeyProvider(jarClassLoader);
+        Assertions.assertThat(provider.isSecurityRule("JarVulnerability")).isFalse();
+      }
+    } finally {
+      Files.deleteIfExists(jarPath);
+    }
+  }
+
+  @Test
+  void test_loads_from_jar_classpath() throws Exception {
+    var jarPath = createTempJar(Map.of(
+      "org/sonar/l10n/py/rules/python/", "",
+      "org/sonar/l10n/py/rules/python/JarVulnerability.json", "{\"type\": \"VULNERABILITY\"}",
+      "org/sonar/l10n/py/rules/python/JarCodeSmell.json", "{\"type\": \"CODE_SMELL\"}"
+    ));
+    try {
+      try (var jarClassLoader = new URLClassLoader(new URL[]{jarPath.toUri().toURL()}, null)) {
+        var provider = new SecurityRuleKeyProvider(jarClassLoader);
+        var urls = jarClassLoader.getResources("org/sonar/l10n/py/rules/python/");
+        Assertions.assertThat(urls.nextElement().toString()).startsWith("jar:file:");
+        Assertions.assertThat(provider.isSecurityRule("JarVulnerability")).isTrue();
+        Assertions.assertThat(provider.isSecurityRule("JarCodeSmell")).isFalse();
+      }
+    } finally {
+      Files.deleteIfExists(jarPath);
+    }
+  }
+
+  @Test
+  void test_bad_jar_url_is_handled_gracefully() throws Exception {
+    // A jar: URL pointing to a non-existent JAR exercises the catch block in scanDir
+    var badJarUrl = new URL("jar:file:/nonexistent-path/missing.jar!/org/sonar/l10n/py/rules/python/");
+    ClassLoader badLoader = new ClassLoader(null) {
+      @Override
+      public Enumeration getResources(String name) {
+        return Collections.enumeration(List.of(badJarUrl));
+      }
+    };
+    // Must not throw — error is logged at DEBUG and loading continues
+    var provider = new SecurityRuleKeyProvider(badLoader);
+    Assertions.assertThat(provider.isSecurityRule("anything")).isFalse();
+  }
+
+  @Test
+  void test_file_url_pointing_to_non_directory_is_skipped() throws Exception {
+    // A file: URL pointing to a regular file (not a directory) exercises the !isDirectory() early return
+    String tmpdir = System.getenv("TMPDIR");
+    Path tmpBase = (tmpdir != null) ? Path.of(tmpdir) : Path.of(System.getProperty("java.io.tmpdir"));
+    var plainFile = Files.createTempFile(tmpBase, "not-a-dir", ".json");
+    try {
+      ClassLoader fileLoader = new ClassLoader(null) {
+        @Override
+        public Enumeration getResources(String name) throws IOException {
+          return Collections.enumeration(List.of(plainFile.toUri().toURL()));
+        }
+      };
+      var provider = new SecurityRuleKeyProvider(fileLoader);
+      Assertions.assertThat(provider.isSecurityRule("anything")).isFalse();
+    } finally {
+      Files.deleteIfExists(plainFile);
+    }
+  }
+
+  private static Path createTempJar(Map entries) throws IOException {
+    String tmpdir = System.getenv("TMPDIR");
+    Path tmpBase = (tmpdir != null) ? Path.of(tmpdir) : Path.of(System.getProperty("java.io.tmpdir"));
+    var jarPath = Files.createTempFile(tmpBase, "test-rules", ".jar");
+    try (var jos = new JarOutputStream(Files.newOutputStream(jarPath))) {
+      for (var entry : entries.entrySet()) {
+        jos.putNextEntry(new JarEntry(entry.getKey()));
+        jos.write(entry.getValue().getBytes(StandardCharsets.UTF_8));
+        jos.closeEntry();
+      }
+    }
+    return jarPath;
+  }
+}
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/parser/StaxParserTest.java b/python-commons/src/test/java/org/sonar/plugins/python/parser/StaxParserTest.java
index 424ce22e0c..fe711cd022 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/parser/StaxParserTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/parser/StaxParserTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/pylint/PylintRulesDefinitionTest.java b/python-commons/src/test/java/org/sonar/plugins/python/pylint/PylintRulesDefinitionTest.java
index 7d01488173..ae7b965f8d 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/pylint/PylintRulesDefinitionTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/pylint/PylintRulesDefinitionTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/pylint/PylintSensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/pylint/PylintSensorTest.java
index 079324d6b9..c7d81bfc15 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/pylint/PylintSensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/pylint/PylintSensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,9 @@
  */
 package org.sonar.plugins.python.pylint;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -31,16 +34,13 @@
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.TextRange;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.rule.Severity;
-import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
 import org.sonar.api.batch.sensor.issue.ExternalIssue;
 import org.sonar.api.batch.sensor.issue.IssueLocation;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.rules.RuleType;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.api.utils.Version;
+import org.sonar.scanner.plugin.api.impl.sensor.DefaultSensorDescriptor;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -221,7 +221,7 @@ private static List executeSensorImporting(int majorVersion, int
     SensorContextTester context = SensorContextTester.create(baseDir);
     try (Stream fileStream = Files.list(PROJECT_DIR)) {
       fileStream.forEach(file -> addFileToContext(context, baseDir, file));
-      context.setRuntime(SonarRuntimeImpl.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER));
+      context.setRuntime(TestSonarRuntime.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER, SonarEdition.DEVELOPER));
       if (fileName != null) {
         String path = PROJECT_DIR.resolve(fileName).toAbsolutePath().toString();
         if (useLegacyKey) {
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/ruff/RuffRulesDefinitionTest.java b/python-commons/src/test/java/org/sonar/plugins/python/ruff/RuffRulesDefinitionTest.java
index 0b40366229..5d5522b22c 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/ruff/RuffRulesDefinitionTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/ruff/RuffRulesDefinitionTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/ruff/RuffSensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/ruff/RuffSensorTest.java
index f7038ae251..03080e96a7 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/ruff/RuffSensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/ruff/RuffSensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,12 +16,18 @@
  */
 package org.sonar.plugins.python.ruff;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
+import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Stream;
 import javax.annotation.Nullable;
 import org.junit.jupiter.api.Test;
@@ -29,21 +35,25 @@
 import org.slf4j.event.Level;
 import org.sonar.api.SonarEdition;
 import org.sonar.api.SonarQubeSide;
+import org.sonar.api.batch.fs.FilePredicates;
+import org.sonar.api.batch.fs.FileSystem;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.TextRange;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.rule.Severity;
-import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import org.sonar.api.batch.sensor.SensorContext;
 import org.sonar.api.batch.sensor.issue.ExternalIssue;
 import org.sonar.api.batch.sensor.issue.IssueLocation;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.rules.RuleType;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.api.utils.Version;
+import org.sonar.scanner.plugin.api.impl.sensor.DefaultSensorDescriptor;
+import org.sonarsource.analyzer.commons.internal.json.simple.parser.ParseException;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class RuffSensorTest {
 
@@ -212,6 +222,64 @@ void report_on_empty_file() throws IOException {
     assertThat(firstTextRange.end().lineOffset()).isZero();
   }
 
+  @Test
+  void issues_with_absolute_path_from_different_base_dir() throws IOException {
+    List externalIssues = executeSensorImporting(7, 9, "absolute-path-different-base-dir.json");
+    assertThat(externalIssues).hasSize(1);
+
+    ExternalIssue first = externalIssues.get(0);
+    assertThat(first.ruleKey()).hasToString("external_ruff:D100");
+    IssueLocation firstPrimaryLoc = first.primaryLocation();
+    assertThat(firstPrimaryLoc.inputComponent().key()).isEqualTo(RUFF_FILE);
+    assertThat(firstPrimaryLoc.message()).isEqualTo("Missing docstring in public module");
+
+    assertNoErrorWarnLogs(logTester);
+  }
+
+  @Test
+  void most_specific_relative_path_is_preferred_when_multiple_suffixes_match() throws IOException {
+    // The report path ends with both "ruff/file1.py" and the longer, more specific "ruff/other/ruff/file1.py".
+    // The longer match must win instead of being treated as ambiguous.
+    List externalIssues = executeSensorImporting(7, 9, "nested-relative-path-match.json");
+    assertThat(externalIssues).hasSize(1);
+
+    ExternalIssue first = externalIssues.get(0);
+    assertThat(first.ruleKey()).hasToString("external_ruff:D100");
+    IssueLocation firstPrimaryLoc = first.primaryLocation();
+    assertThat(firstPrimaryLoc.inputComponent().key()).isEqualTo("python-project:ruff/other/ruff/file1.py");
+    assertThat(firstPrimaryLoc.message()).isEqualTo("Missing docstring in public module");
+
+    assertNoErrorWarnLogs(logTester);
+  }
+
+  @Test
+  void ambiguous_relative_path_match_is_not_resolved() throws IOException, ParseException {
+    // Two distinct input files sharing the exact same relative path can only occur when the file system indexes
+    // them without deduplication (e.g. across modules in a multi-module reactor); SensorContextTester's own
+    // FileSystem dedupes by relative path, so the FileSystem is mocked here to reproduce that scenario directly.
+    InputFile firstCandidate = mock(InputFile.class);
+    when(firstCandidate.relativePath()).thenReturn("ruff/file1.py");
+    InputFile secondCandidate = mock(InputFile.class);
+    when(secondCandidate.relativePath()).thenReturn("ruff/file1.py");
+
+    FilePredicates predicates = mock(FilePredicates.class);
+    FileSystem fileSystem = mock(FileSystem.class);
+    when(fileSystem.predicates()).thenReturn(predicates);
+    when(fileSystem.inputFile(any())).thenReturn(null);
+    when(fileSystem.inputFiles(any())).thenReturn(List.of(firstCandidate, secondCandidate));
+
+    SensorContext context = mock(SensorContext.class);
+    when(context.fileSystem()).thenReturn(fileSystem);
+
+    Set unresolvedInputFiles = new HashSet<>();
+    File reportFile = PROJECT_DIR.resolve("absolute-path-different-base-dir.json").toFile();
+    ruffSensor.importReport(reportFile, context, unresolvedInputFiles);
+
+    assertThat(unresolvedInputFiles).containsExactly("/builds/ci-runner-42/workspace/project/ruff/file1.py");
+    assertThat(logTester.logs(Level.DEBUG))
+      .contains("Multiple files equally match the path '/builds/ci-runner-42/workspace/project/ruff/file1.py', skipping ambiguous match");
+  }
+
   @Test
   void unknown_json_file_path() throws IOException {
     List externalIssues = executeSensorImporting(7, 9, RUFF_REPORT_UNKNOWN_FILES);
@@ -307,9 +375,9 @@ private static List executeSensorImporting(int majorVersion, int
     @Nullable String fileName) throws IOException {
     Path baseDir = PROJECT_DIR.getParent();
     SensorContextTester context = SensorContextTester.create(baseDir);
-    try (Stream fileStream = Files.list(PROJECT_DIR)) {
-      fileStream.forEach(file -> addFileToContext(context, baseDir, file));
-      context.setRuntime(SonarRuntimeImpl.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER,
+    try (Stream fileStream = Files.walk(PROJECT_DIR)) {
+      fileStream.filter(Files::isRegularFile).forEach(file -> addFileToContext(context, baseDir, file));
+      context.setRuntime(TestSonarRuntime.forSonarQube(Version.create(majorVersion, minorVersion), SonarQubeSide.SERVER,
         SonarEdition.DEVELOPER));
       if (fileName != null) {
         String path = PROJECT_DIR.resolve(fileName).toAbsolutePath().toString();
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/telemetry/SensorTelemetryStorageTest.java b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/SensorTelemetryStorageTest.java
index 685dbe6270..5aea4596a6 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/telemetry/SensorTelemetryStorageTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/SensorTelemetryStorageTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,8 @@
  */
 package org.sonar.plugins.python.telemetry;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestSonarRuntime;
 import java.io.File;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -24,8 +26,6 @@
 import org.sonar.api.SonarEdition;
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.batch.sensor.SensorContext;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
-import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.api.utils.Version;
 
@@ -74,7 +74,7 @@ void no_crash_on_exception() {
 
   private SensorContext sensorContext(Version version) {
     var sensorContext = spy(SensorContextTester.create(new File("")));
-    sensorContext.setRuntime(SonarRuntimeImpl.forSonarQube(version, SonarQubeSide.SERVER, SonarEdition.DEVELOPER));
+    sensorContext.setRuntime(TestSonarRuntime.forSonarQube(version, SonarQubeSide.SERVER, SonarEdition.DEVELOPER));
     return sensorContext;
   }
 }
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/ImportsTelemetryCollectorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/ImportsTelemetryCollectorTest.java
new file mode 100644
index 0000000000..3adee067b0
--- /dev/null
+++ b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/ImportsTelemetryCollectorTest.java
@@ -0,0 +1,127 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.telemetry.collectors;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.sonar.plugins.python.api.PythonVisitorContext;
+import org.sonar.python.TestPythonVisitorRunner;
+import org.sonar.python.caching.CacheContextImpl;
+import org.sonar.python.semantic.ProjectLevelSymbolTable;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ImportsTelemetryCollectorTest {
+
+  private static PythonVisitorContext createContext(String code) {
+    var mockFile = new TestPythonVisitorRunner.MockPythonFile("", "test.py", code);
+    return TestPythonVisitorRunner.createContext(mockFile, null, "", ProjectLevelSymbolTable.empty(), CacheContextImpl.dummyCache());
+  }
+
+  private static ImportsTelemetry collectFrom(String code) {
+    var collector = new ImportsTelemetryCollector();
+    collector.collect(createContext(code).rootTree());
+    return collector.getTelemetry();
+  }
+
+  @Test
+  void simpleImport() {
+    var telemetry = collectFrom("import pandas");
+    assertThat(telemetry.importedModules()).containsExactly("pandas");
+  }
+
+  @Test
+  void dottedImportRecordsOnlyTopLevel() {
+    var telemetry = collectFrom("import os.path");
+    assertThat(telemetry.importedModules()).containsExactly("os");
+  }
+
+  @Test
+  void fromImportRecordsModule() {
+    var telemetry = collectFrom("from pandas import DataFrame");
+    assertThat(telemetry.importedModules()).containsExactly("pandas");
+  }
+
+  @Test
+  void fromDottedImportRecordsOnlyTopLevel() {
+    var telemetry = collectFrom("from os.path import join");
+    assertThat(telemetry.importedModules()).containsExactly("os");
+  }
+
+  @Test
+  void wildcardImportRecordsModule() {
+    var telemetry = collectFrom("from os import *");
+    assertThat(telemetry.importedModules()).containsExactly("os");
+  }
+
+  @ParameterizedTest
+  @ValueSource(strings = {
+    "from . import foo",
+    "from ..utils import bar",
+    "",
+    "x = 1\nprint(x)"
+  })
+  void producesEmptyImportedModules(String code) {
+    var telemetry = collectFrom(code);
+    assertThat(telemetry.importedModules()).isEmpty();
+  }
+
+  @Test
+  void multipleModulesOnOneImportStatement() {
+    var telemetry = collectFrom("import os, sys");
+    assertThat(telemetry.importedModules()).containsExactlyInAnyOrder("os", "sys");
+  }
+
+  @Test
+  void duplicatesAreDeduplicatedAcrossFiles() {
+    var collector = new ImportsTelemetryCollector();
+    collector.collect(createContext("import pandas").rootTree());
+    collector.collect(createContext("import pandas\nimport numpy").rootTree());
+    var telemetry = collector.getTelemetry();
+    assertThat(telemetry.importedModules()).containsExactlyInAnyOrder("pandas", "numpy");
+  }
+
+  @Test
+  void namesAreNormalized() {
+    // Module names with uppercase are lowercased
+    var telemetry = collectFrom("import Pandas");
+    assertThat(telemetry.importedModules()).containsExactly("pandas");
+  }
+
+  @Test
+  void nameNotInWhiteList() {
+    String longName = "a";
+    var telemetry = collectFrom("import " + longName);
+    assertThat(telemetry.importedModules()).isEmpty();
+  }
+
+
+  @Test
+  void mixOfImportTypes() {
+    var telemetry = collectFrom("""
+      import os
+      import os.path
+      from pandas import DataFrame
+      from numpy.linalg import norm
+      from . import local_module
+      from ..utils import helper
+      from sys import *
+      """);
+    assertThat(telemetry.importedModules()).containsExactlyInAnyOrder("os", "pandas", "numpy", "sys");
+  }
+}
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryCollectorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryCollectorTest.java
index 706699c733..43a54edb7e 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryCollectorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryCollectorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryTest.java b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryTest.java
index 2d8002821c..628f6f63a6 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TestFileTelemetryTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetryCollectorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetryCollectorTest.java
index 8e562c56e4..11476d2707 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetryCollectorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/telemetry/collectors/TypeInferenceTelemetryCollectorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/warnings/AnalysisWarningsWrapperTest.java b/python-commons/src/test/java/org/sonar/plugins/python/warnings/AnalysisWarningsWrapperTest.java
index e6309cd86a..736d3aee2b 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/warnings/AnalysisWarningsWrapperTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/warnings/AnalysisWarningsWrapperTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/xunit/PythonXUnitSensorTest.java b/python-commons/src/test/java/org/sonar/plugins/python/xunit/PythonXUnitSensorTest.java
index 521d958147..406abb5b72 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/xunit/PythonXUnitSensorTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/xunit/PythonXUnitSensorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,22 +16,22 @@
  */
 package org.sonar.plugins.python.xunit;
 
+import com.sonarsource.scanner.engine.sensor.test.fixtures.SensorContextTester;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
 import java.io.File;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.slf4j.event.Level;
 import org.sonar.api.batch.fs.InputComponent;
-import org.sonar.api.batch.fs.internal.DefaultFileSystem;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.batch.sensor.internal.SensorContextTester;
-import org.sonar.api.config.internal.ConfigurationBridge;
-import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.measures.CoreMetrics;
 import org.sonar.api.measures.Metric;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.plugins.python.warnings.AnalysisWarningsWrapper;
+import org.sonar.scanner.plugin.api.impl.config.ConfigurationBridge;
+import org.sonar.scanner.plugin.api.impl.config.MapSettings;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultFileSystem;
+import org.sonar.scanner.plugin.api.impl.fs.DefaultInputFile;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.spy;
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestCaseTest.java b/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestCaseTest.java
index 452e799819..ef1210842a 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestCaseTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestCaseTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,7 +20,7 @@
 import java.util.Map;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class TestCaseTest {
   @Test
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestResultTest.java b/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestResultTest.java
index 7a4ec8a941..86b82739a8 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestResultTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestResultTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestSuiteTest.java b/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestSuiteTest.java
index c4cdcbf8a4..ce225f3871 100644
--- a/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestSuiteTest.java
+++ b/python-commons/src/test/java/org/sonar/plugins/python/xunit/TestSuiteTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestCodeSmell.json b/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestCodeSmell.json
new file mode 100644
index 0000000000..909cd63128
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestCodeSmell.json
@@ -0,0 +1,6 @@
+{
+  "title": "Test code smell rule",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "defaultSeverity": "Minor"
+}
diff --git a/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestMalformedJson.json b/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestMalformedJson.json
new file mode 100644
index 0000000000..7b1b3603a9
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestMalformedJson.json
@@ -0,0 +1 @@
+not valid json {{{
diff --git a/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestNoType.json b/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestNoType.json
new file mode 100644
index 0000000000..4461ce2c66
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestNoType.json
@@ -0,0 +1,4 @@
+{
+  "title": "Test rule with no type field",
+  "status": "ready"
+}
diff --git a/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestVulnerability.json b/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestVulnerability.json
new file mode 100644
index 0000000000..716ea68ce0
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/l10n/py/rules/python/TestVulnerability.json
@@ -0,0 +1,6 @@
+{
+  "title": "Test vulnerability rule",
+  "type": "VULNERABILITY",
+  "status": "ready",
+  "defaultSeverity": "Critical"
+}
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage.4.4.2-multi-sources.xml b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage.4.4.2-multi-sources.xml
index b3c177bdb4..2e07a57c25 100644
--- a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage.4.4.2-multi-sources.xml
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage.4.4.2-multi-sources.xml
@@ -3,8 +3,8 @@
 	
 	
 	
-		src/test/resources/org/sonar/plugins/python/coverage-reports/sources/folder2
-		src/test/resources/org/sonar/plugins/python/coverage-reports/sources/folder1
+		sources/folder2
+		sources/folder1
 	
 	
 		
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage.4.4.2.xml b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage.4.4.2.xml
index d669c716cb..8afe063c73 100644
--- a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage.4.4.2.xml
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage.4.4.2.xml
@@ -3,7 +3,7 @@
 	
 	
 	
-		src/test/resources/org/sonar/plugins/python/coverage-reports/sources
+		sources
 	
 	
 		
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_source_invalid_directory.xml b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_source_invalid_directory.xml
index e29e35cbee..97aa89d235 100644
--- a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_source_invalid_directory.xml
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_source_invalid_directory.xml
@@ -3,8 +3,8 @@
 	
 	
 	
-		src/test/resources/org/sonar/plugins/python/coverage-reports/sources/file1.py
-		src/test/resources/org/sonar/plugins/python/coverage-reports/sources/file2.py
+		sources/file1.py
+		sources/file2.py
 	
 	
 
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_with_unresolved_absolute_path.xml b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_with_unresolved_absolute_path.xml
index 9b2255816a..d8735570e1 100644
--- a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_with_unresolved_absolute_path.xml
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_with_unresolved_absolute_path.xml
@@ -3,7 +3,7 @@
     SYSTEM 'http://cobertura.sourceforge.net/xml/coverage-03.dtd'>
 
   
-    src/test/resources/org/sonar/plugins/python/coverage-reports
+    sources
   
 
   
@@ -21,7 +21,7 @@
 
     
       
-        
+        
           
             
             
@@ -33,7 +33,7 @@
 
     
       
-        
+        
           
             
             
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_with_unresolved_path.xml b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_with_unresolved_path.xml
index abb4ed5383..cfb719d147 100644
--- a/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_with_unresolved_path.xml
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/coverage-reports/coverage_with_unresolved_path.xml
@@ -3,12 +3,12 @@
     SYSTEM 'http://cobertura.sourceforge.net/xml/coverage-03.dtd'>
 
   
-    src/test/resources/org/sonar/plugins/python/coverage-reports
+    sources
   
   
     
       
-        
+        
           
             
             
@@ -20,7 +20,7 @@
 
     
       
-        
+        
           
             
             
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array.ipynb b/python-commons/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array.ipynb
new file mode 100644
index 0000000000..8c14af6945
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array.ipynb
@@ -0,0 +1,22 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(\"Test 1\")\ntestA = \"1\"\nprint(\"Test 2\")\ntestB = \"2\"\nprint(\"Test 3\")\ntestC = \"3\"\n\n\ntestAll = testA + testB + testC\n\nprint(testAll)"
+      ]
+    }
+  ],
+  "metadata": {
+    "language_info": {
+      "name": "python"
+    },
+    "name": "test",
+    "notebookId": 1
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array_no_trailing_newline.ipynb b/python-commons/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array_no_trailing_newline.ipynb
new file mode 100644
index 0000000000..a27406576a
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array_no_trailing_newline.ipynb
@@ -0,0 +1,23 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "x = 1\ny",
+        " = 2"
+      ]
+    }
+  ],
+  "metadata": {
+    "language_info": {
+      "name": "python"
+    },
+    "name": "test",
+    "notebookId": 1
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/ruff/absolute-path-different-base-dir.json b/python-commons/src/test/resources/org/sonar/plugins/python/ruff/absolute-path-different-base-dir.json
new file mode 100644
index 0000000000..57dc06e781
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/ruff/absolute-path-different-base-dir.json
@@ -0,0 +1,18 @@
+[
+  {
+    "code": "D100",
+    "end_location": {
+      "column": 1,
+      "row": 1
+    },
+    "filename": "/builds/ci-runner-42/workspace/project/ruff/file1.py",
+    "fix": null,
+    "location": {
+      "column": 1,
+      "row": 1
+    },
+    "message": "Missing docstring in public module",
+    "noqa_row": 1,
+    "url": "https://beta.ruff.rs/docs/rules/undocumented-public-module"
+  }
+]
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/ruff/nested-relative-path-match.json b/python-commons/src/test/resources/org/sonar/plugins/python/ruff/nested-relative-path-match.json
new file mode 100644
index 0000000000..72c60beb37
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/ruff/nested-relative-path-match.json
@@ -0,0 +1,18 @@
+[
+  {
+    "code": "D100",
+    "end_location": {
+      "column": 1,
+      "row": 1
+    },
+    "filename": "/builds/ci-runner-42/workspace/project/ruff/other/ruff/file1.py",
+    "fix": null,
+    "location": {
+      "column": 1,
+      "row": 1
+    },
+    "message": "Missing docstring in public module",
+    "noqa_row": 1,
+    "url": "https://beta.ruff.rs/docs/rules/undocumented-public-module"
+  }
+]
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/ruff/other/ruff/file1.py b/python-commons/src/test/resources/org/sonar/plugins/python/ruff/other/ruff/file1.py
new file mode 100644
index 0000000000..0b63d1f206
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/ruff/other/ruff/file1.py
@@ -0,0 +1,2 @@
+def duplicate():
+    pass
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/empty_test_case.py b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/empty_test_case.py
new file mode 100644
index 0000000000..b1c6998ec9
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/empty_test_case.py
@@ -0,0 +1,6 @@
+import unittest
+
+
+class EmptyTestCase(unittest.TestCase):
+    def helper(self):
+        return 42
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/framework_helper.py b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/framework_helper.py
new file mode 100644
index 0000000000..d48475eaa6
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/framework_helper.py
@@ -0,0 +1,6 @@
+import doctest
+
+
+def regular_func(x):
+    x = 42
+    assert (a, b)
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/helper_with_tests.py b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/helper_with_tests.py
new file mode 100644
index 0000000000..62684e3bfe
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/helper_with_tests.py
@@ -0,0 +1,5 @@
+import pytest
+
+def test_helper(x):
+    x = 42
+    assert x == 42
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/python-version/__init__.py b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/python-version/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/python-version/type_alias.py b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/python-version/type_alias.py
new file mode 100644
index 0000000000..c6ace5cf9c
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/python-version/type_alias.py
@@ -0,0 +1,3 @@
+from typing import TypeAlias
+
+Alias: TypeAlias = int
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/requirements.txt b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/requirements.txt
index d66fb36076..ecb99f59e9 100644
--- a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/requirements.txt
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/requirements.txt
@@ -15,6 +15,15 @@ packageWithFixedVersion == 0.6.1
 packageWithConstraints [security] >= 2.8.1, == 2.8.* ; python_version < "2.7"
 packageWithVCS @ https://github.com/urllib3/urllib3/archive/refs/tags/1.26.8.zip
 
+# Package names should also be recognized when there is no space before the operator or extras
+torch>=1.10
+labml-helpers>=0.4.84
+gym[atari]
+numpy==1.19
+flask[async]>=2.0
+requests;python_version<"3.8"
+certifi@https://example.com/certifi.zip
+
 # For know, we ignore extra requirements files referred in requirements.txt
 -r other-requirements.txt
 -c constraints.txt
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/test_file.py b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/test_file.py
index 2f723359d7..3f3e09b9f7 100644
--- a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/test_file.py
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/test_file.py
@@ -1,3 +1,5 @@
-def test_func(x):
+# Triggers the filename heuristic (test_*.py) but not the pytest-pattern heuristic.
+# Used in tests that specifically exercise path-based test detection.
+def regular_func(x):
     x = 42
     assert (a, b)
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/test_paths_loader.py b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/test_paths_loader.py
new file mode 100644
index 0000000000..27b6308991
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/test_paths_loader.py
@@ -0,0 +1,2 @@
+def load_paths():
+    return []
diff --git a/python-commons/src/test/resources/org/sonar/plugins/python/sensor/tests/test_file.py b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/tests/test_file.py
new file mode 100644
index 0000000000..3442ca7035
--- /dev/null
+++ b/python-commons/src/test/resources/org/sonar/plugins/python/sensor/tests/test_file.py
@@ -0,0 +1,5 @@
+# Lives under a `tests/` directory to trigger the directory-based heuristic.
+# See sensor/test_file.py for the companion file used to test the filename-based heuristic.
+def test_func(x):
+    x = 42
+    assert (a, b)
diff --git a/python-frontend/pom.xml b/python-frontend/pom.xml
index 29748228dc..338717481a 100644
--- a/python-frontend/pom.xml
+++ b/python-frontend/pom.xml
@@ -6,7 +6,7 @@
   
     org.sonarsource.python
     python
-    5.19-SNAPSHOT
+    5.30-SNAPSHOT
   
 
   python-frontend
@@ -37,6 +37,11 @@
       sonar-plugin-api-test-fixtures
       test
     
+    
+      org.sonarsource.scanner.engine
+      sensor-test-fixtures
+      test
+    
 
     
       org.junit.jupiter
@@ -74,10 +79,6 @@
       sonar-analyzer-commons
       compile
     
-    
-      org.sonarsource.sonarqube
-      sonar-plugin-api-impl
-    
     
       com.fasterxml.jackson.core
       jackson-databind
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/GeneratedIPythonFile.java b/python-frontend/src/main/java/org/sonar/plugins/python/GeneratedIPythonFile.java
index bafb1ec5c8..2c71f5f637 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/GeneratedIPythonFile.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/GeneratedIPythonFile.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/IpynbNotebookParser.java b/python-frontend/src/main/java/org/sonar/plugins/python/IpynbNotebookParser.java
index 841cb09fd7..d50eed6382 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/IpynbNotebookParser.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/IpynbNotebookParser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -240,57 +240,154 @@ private static NotebookParsingData parseSourceArray(int startLine, JsonParser jP
     JsonLocation tokenLocation = jParser.currentTokenLocation();
     // In case of an empty cell, we don't add an extra line
     var lastSourceLine = "\n";
+    var lastOffset = LineSplitOffset.NONE;
+    // Whether the array element about to be processed starts on a fresh physical line. An element only
+    // does if the previous one ended with a newline; otherwise it is glued onto the previous element's
+    // still-open line and must not get its own locationMap entry (there is only room for one per line).
+    var startsNewLine = true;
     while (jParser.nextToken() != JsonToken.END_ARRAY) {
       String sourceLine = jParser.getValueAsString();
       var newTokenLocation = jParser.currentTokenLocation();
-      var countEscapedChar = countEscapeCharacters(sourceLine);
-      cellData.addLineToSource(sourceLine, newTokenLocation.getLineNr(), newTokenLocation.getColumnNr(), countEscapedChar, isCompressed);
+      lastOffset = addSourceArrayElement(cellData, sourceLine, newTokenLocation, isCompressed, startsNewLine);
+      startsNewLine = sourceLine.endsWith("\n");
       lastSourceLine = sourceLine;
       tokenLocation = newTokenLocation;
     }
+    // Column right after the last array element's content, accounting for any lines split out of a
+    // multiline string contained in that element.
+    int lastColumn = tokenLocation.getColumnNr() + lastOffset.length() + lastOffset.extraChars();
     if (!lastSourceLine.endsWith("\n")) {
       cellData.appendToSource("\n");
     } else {
       // if the last string of the array ends with a newline character we should add this new line to our representation
       var newLineLocation = new IPythonLocation(
         tokenLocation.getLineNr(),
-        tokenLocation.getColumnNr(),
-        List.of(new EscapeCharPositionInfo(tokenLocation.getColumnNr(), 1)),
+        lastColumn,
+        List.of(new EscapeCharPositionInfo(lastColumn, 1)),
         false);
       cellData.addLineToSource("\n", newLineLocation);
     }
     // Account for the last cell delimiter
-    cellData.addDelimiterToSource(SONAR_PYTHON_NOTEBOOK_CELL_DELIMITER + "\n", tokenLocation.getLineNr(), tokenLocation.getColumnNr());
+    cellData.addDelimiterToSource(SONAR_PYTHON_NOTEBOOK_CELL_DELIMITER + "\n", tokenLocation.getLineNr(), lastColumn);
     return cellData;
   }
 
+  /**
+   * Adds a single "source" array element to the cell data. Most array elements represent exactly one
+   * Python source line, but the JSON schema also allows an element to itself contain embedded newlines
+   * (a multiline string used as one array item), in which case it is split the same way a top-level
+   * multiline string "source" value is. Returns the raw-content offset consumed within the element's
+   * JSON token, relative to its token location, so the caller can correctly position whatever follows it.
+   *
+   * 
                  If the previous element did not end with a newline, this element continues that still-open
+   * physical line rather than starting a new one: its first (or only) segment is appended as plain text,
+   * with no locationMap entry of its own, since a generated line can only be anchored to a single
+   * original position.
+   */
+  private static LineSplitOffset addSourceArrayElement(NotebookParsingData cellData, String sourceLine, JsonLocation tokenLocation, boolean isCompressed,
+    boolean startsNewLine) {
+    List lines = sourceLine.lines().toList();
+    if (lines.size() <= 1) {
+      if (!startsNewLine) {
+        cellData.appendToSource(sourceLine);
+        return LineSplitOffset.NONE;
+      }
+      var countEscapedChar = countEscapeCharacters(sourceLine);
+      cellData.addLineToSource(sourceLine, tokenLocation.getLineNr(), tokenLocation.getColumnNr(), countEscapedChar, isCompressed);
+      return LineSplitOffset.NONE;
+    }
+    // The element packs multiple Python lines into a single array entry: each embedded line needs its
+    // own location entry, the same way parseSourceMultilineString handles a plain-string "source" -
+    // except its first line, which only gets one if it genuinely starts a new physical line.
+    var offset = addSourceLinesToCellData(cellData, lines, tokenLocation, true, startsNewLine);
+    if (sourceLine.endsWith("\n")) {
+      cellData.appendToSource("\n");
+      offset = offset.plusNewline();
+    }
+    return offset;
+  }
+
   private static NotebookParsingData parseSourceMultilineString(int startLine, JsonParser jParser) throws IOException {
     NotebookParsingData cellData = NotebookParsingData.fromLine(startLine);
     String sourceLine = jParser.getValueAsString();
     JsonLocation tokenLocation = jParser.currentTokenLocation();
-    var previousLen = 0;
-    var previousExtraChars = 0;
 
-    for (String line : sourceLine.lines().toList()) {
-      var countEscapedChar = countEscapeCharacters(line);
-      var currentCount = countEscapedChar.stream().mapToInt(EscapeCharPositionInfo::numberOfExtraChars).sum();
-      cellData.addLineToSource(line, new IPythonLocation(tokenLocation.getLineNr(),
-        tokenLocation.getColumnNr() + previousLen + previousExtraChars, countEscapedChar, true));
+    List lines = sourceLine.lines().toList();
+    var offset = addSourceLinesToCellData(cellData, lines, tokenLocation, true, true);
+    // The last split line is always followed by a newline: either the cell delimiter or the next cell's content.
+    // An empty source ("") has no split line to terminate, so there is nothing to append here - doing so
+    // regardless would insert a physical blank line with no locationMap entry of its own, drifting every
+    // following location by one.
+    if (!lines.isEmpty()) {
       cellData.appendToSource("\n");
-      previousLen += line.length() + 2;
-      previousExtraChars += currentCount;
+      offset = offset.plusNewline();
     }
 
     if (sourceLine.endsWith("\n")) {
-      var column = tokenLocation.getColumnNr() + previousExtraChars + previousLen;
+      var column = tokenLocation.getColumnNr() + offset.length() + offset.extraChars();
       cellData.addLineToSource("\n", new IPythonLocation(tokenLocation.getLineNr(), column, List.of(new EscapeCharPositionInfo(column, 1)), true));
-      previousLen += 2;
+      offset = offset.plusNewline();
     }
     // Account for the last cell delimiter
-    cellData.addDelimiterToSource(SONAR_PYTHON_NOTEBOOK_CELL_DELIMITER + "\n", tokenLocation.getLineNr(), tokenLocation.getColumnNr() + previousExtraChars + previousLen);
+    cellData.addDelimiterToSource(SONAR_PYTHON_NOTEBOOK_CELL_DELIMITER + "\n", tokenLocation.getLineNr(), tokenLocation.getColumnNr() + offset.length() + offset.extraChars());
     return cellData;
   }
 
+  /**
+   * Splits a JSON string value's content into individual Python source lines and adds each to the cell
+   * data, computing the column of every line within the original JSON token. Every line except the last
+   * is followed by an explicit newline in the aggregated source, since it was followed by an embedded
+   * newline in the JSON value; the caller decides how to terminate the last one.
+   *
+   * 
                  When {@code firstLineStartsNewLine} is false, the first line continues a still-open physical line
+   * from whatever was appended just before it, so it is added as plain text with no locationMap entry of
+   * its own (a generated line can only be anchored to a single original position).
+   */
+  private static LineSplitOffset addSourceLinesToCellData(NotebookParsingData cellData, List lines, JsonLocation tokenLocation, boolean isCompressed,
+    boolean firstLineStartsNewLine) {
+    var offset = LineSplitOffset.NONE;
+    for (int i = 0; i < lines.size(); i++) {
+      String line = lines.get(i);
+      var countEscapedChar = countEscapeCharacters(line);
+      var currentExtraChars = countEscapedChar.stream().mapToInt(EscapeCharPositionInfo::numberOfExtraChars).sum();
+      if (i > 0 || firstLineStartsNewLine) {
+        cellData.addLineToSource(line, new IPythonLocation(tokenLocation.getLineNr(),
+          tokenLocation.getColumnNr() + offset.length() + offset.extraChars(), countEscapedChar, isCompressed));
+      } else {
+        cellData.appendToSource(line);
+      }
+      boolean hasMoreLines = i < lines.size() - 1;
+      if (hasMoreLines) {
+        cellData.appendToSource("\n");
+        offset = offset.plusLine(line.length(), currentExtraChars);
+      } else {
+        offset = offset.plusLastLine(line.length(), currentExtraChars);
+      }
+    }
+    return offset;
+  }
+
+  /**
+   * Tracks how many raw JSON characters (and how many of those are "extra" escape characters) have
+   * been consumed from a JSON string token while splitting it into individual source lines.
+   */
+  private record LineSplitOffset(int length, int extraChars) {
+    static final LineSplitOffset NONE = new LineSplitOffset(0, 0);
+
+    LineSplitOffset plusLine(int lineLength, int lineExtraChars) {
+      // +2 accounts for the JSON-escaped "\n" (backslash + n) separating this line from the next one.
+      return new LineSplitOffset(length + lineLength + 2, extraChars + lineExtraChars);
+    }
+
+    LineSplitOffset plusLastLine(int lineLength, int lineExtraChars) {
+      return new LineSplitOffset(length + lineLength, extraChars + lineExtraChars);
+    }
+
+    LineSplitOffset plusNewline() {
+      return new LineSplitOffset(length + 2, extraChars);
+    }
+  }
+
   private static List countEscapeCharacters(String sourceLine) {
     List escapeCharPositionInfoList = new LinkedList<>();
     var arr = sourceLine.toCharArray();
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/NotebookParsingData.java b/python-frontend/src/main/java/org/sonar/plugins/python/NotebookParsingData.java
index 90759bdcae..19c477fde9 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/NotebookParsingData.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/NotebookParsingData.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/NotebookTestUtils.java b/python-frontend/src/main/java/org/sonar/plugins/python/NotebookTestUtils.java
index f0f37697bf..650f4b716e 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/NotebookTestUtils.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/NotebookTestUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/PythonInputFile.java b/python-frontend/src/main/java/org/sonar/plugins/python/PythonInputFile.java
index 0279198e9c..c558609ae6 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/PythonInputFile.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/PythonInputFile.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/PythonInputFileImpl.java b/python-frontend/src/main/java/org/sonar/plugins/python/PythonInputFileImpl.java
index 465e203847..5185c1a595 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/PythonInputFileImpl.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/PythonInputFileImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/PythonTestFileClassifier.java b/python-frontend/src/main/java/org/sonar/plugins/python/PythonTestFileClassifier.java
new file mode 100644
index 0000000000..d172f4562e
--- /dev/null
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/PythonTestFileClassifier.java
@@ -0,0 +1,200 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import javax.annotation.Nullable;
+import org.sonar.api.batch.fs.InputFile;
+import org.sonar.api.config.Configuration;
+import org.sonar.plugins.python.api.tree.ClassDef;
+import org.sonar.plugins.python.api.tree.DottedName;
+import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.plugins.python.api.tree.FunctionDef;
+import org.sonar.plugins.python.api.tree.ImportFrom;
+import org.sonar.plugins.python.api.tree.ImportName;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.Statement;
+import org.sonar.plugins.python.api.tree.StatementList;
+import org.sonarsource.analyzer.commons.appsec.TestFileClassifier;
+
+/**
+ * Adds Python-specific structural signals to the shared test-file heuristic.
+ */
+public final class PythonTestFileClassifier {
+
+  private static final String[] TEST_FILE_PATH_PATTERNS = {
+    "**/test/**", "**/tests/**", "**/testing/**",
+    "**/Test/**", "**/Tests/**", "**/Testing/**",
+    "**/TEST/**", "**/TESTS/**", "**/TESTING/**",
+    "**/conftest.py",
+    "**/test_*.py",
+    "**/*_test.py", "**/*_tests.py",
+    "**/*doctest.py", "**/*doctests.py"
+  };
+  private static final Set TEST_MODULE_ROOTS = Set.of(
+    "pytest", "unittest", "doctest", "hypothesis", "robot", "behave", "pytest_bdd", "nose", "nose2",
+    "testtools", "pytest_mock", "factory_boy", "freezegun",
+    "requests_mock", "respx", "httpretty", "moto", "testcontainers");
+  private static final Set TEST_MODULE_PREFIXES = Set.of("django.test", "twisted.trial");
+  private final TestFileClassifier delegate;
+
+  public PythonTestFileClassifier(Configuration configuration) {
+    delegate = TestFileClassifier.of(configuration, PythonTestFileClassifier::hasTestContentContext, TEST_FILE_PATH_PATTERNS);
+  }
+
+  /**
+   * Determines whether a Python file is likely to contain test code.
+   * @param inputFile analyzed input file
+   * @param tree parsed file tree, when parsing succeeded
+   * @return whether the file is likely test content
+   */
+  public boolean looksLikeTestFile(InputFile inputFile, @Nullable FileInput tree) {
+    return delegate.looksLikeTestFile(inputFile, new PythonContext(inputFile, tree));
+  }
+
+  /**
+   * Determines whether a parsed tree has Python-specific test signals.
+   * @param tree parsed file tree
+   * @return whether the tree contains test-specific imports or declarations
+   */
+  public static boolean hasTestContent(@Nullable FileInput tree) {
+    return looksLikeTestFileByStatements(tree == null ? null : tree.statements());
+  }
+
+  private static boolean hasTestContentContext(TestFileClassifier.Context context) {
+    PythonContext pythonContext = (PythonContext) context;
+    String fileName = fileName(pythonContext.inputFile.relativePath());
+    return isUppercaseTestFileName(fileName)
+      || isCamelCaseTestFileName(fileName)
+      || hasTestContent(pythonContext.tree);
+  }
+
+  private static final class PythonContext implements TestFileClassifier.Context {
+    private final InputFile inputFile;
+    private final FileInput tree;
+
+    private PythonContext(InputFile inputFile, @Nullable FileInput tree) {
+      this.inputFile = inputFile;
+      this.tree = tree;
+    }
+  }
+
+  /**
+   * Determines whether top-level statements identify test content.
+   * @param statements top-level statements
+   * @return whether the statements indicate test content
+   */
+  private static boolean looksLikeTestFileByStatements(@Nullable StatementList statements) {
+    if (statements == null) {
+      return false;
+    }
+    int declarationCount = 0;
+    int testDeclarationCount = 0;
+    for (Statement statement : statements.statements()) {
+      if (isTestFrameworkImport(statement)) {
+        return true;
+      }
+      if (statement instanceof FunctionDef functionDef) {
+        declarationCount++;
+        if (isTestShaped(functionDef.name().name())) {
+          testDeclarationCount++;
+        }
+      } else if (statement instanceof ClassDef classDef) {
+        declarationCount++;
+        if (isTestShaped(classDef.name().name())) {
+          testDeclarationCount++;
+        }
+      }
+    }
+    return testDeclarationCount >= 2 && testDeclarationCount * 2 > declarationCount;
+  }
+
+  /**
+   * Determines whether a statement imports a testing framework or utility.
+   * @param statement top-level statement to inspect
+   * @return whether the statement imports test-specific code
+   */
+  private static boolean isTestFrameworkImport(Statement statement) {
+    if (statement instanceof ImportName importName) {
+      return importName.modules().stream().anyMatch(aliasedName -> isTestModule(moduleNames(aliasedName.dottedName())));
+    }
+    if (statement instanceof ImportFrom importFrom && importFrom.module() != null) {
+      List base = moduleNames(importFrom.module());
+      if (isTestModule(base)) {
+        return true;
+      }
+      return importFrom.importedNames().stream()
+        .anyMatch(importedName -> isTestModule(concat(base, moduleNames(importedName.dottedName()))));
+    }
+    return false;
+  }
+
+  /**
+   * Determines whether a dotted module name belongs to a testing ecosystem.
+   * @param names segments of the imported module name
+   * @return whether the module is test-specific
+   */
+  private static boolean isTestModule(List names) {
+    if (names.isEmpty()) {
+      return false;
+    }
+    if (TEST_MODULE_ROOTS.contains(names.get(0))) {
+      return true;
+    }
+    return names.size() > 1 && TEST_MODULE_PREFIXES.contains(names.get(0) + "." + names.get(1));
+  }
+
+  private static List moduleNames(@Nullable DottedName dottedName) {
+    if (dottedName == null) {
+      return List.of();
+    }
+    return dottedName.names().stream().map(Name::name).toList();
+  }
+
+  private static List concat(List base, List tail) {
+    List combined = new ArrayList<>(base);
+    combined.addAll(tail);
+    return combined;
+  }
+
+  private static boolean isTestShaped(String name) {
+    String lowerCaseName = name.toLowerCase(Locale.ROOT);
+    return lowerCaseName.startsWith("test")
+      && (name.length() == 4 || !Character.isLowerCase(name.charAt(4)));
+  }
+
+  private static boolean isUppercaseTestFileName(String fileName) {
+    return fileName.startsWith("Test")
+      && fileName.endsWith(".py")
+      && (fileName.length() == 7 || !Character.isLowerCase(fileName.charAt(4)));
+  }
+
+  private static boolean isCamelCaseTestFileName(String fileName) {
+    return fileName.startsWith("test")
+      && fileName.endsWith(".py")
+      && Character.isUpperCase(fileName.charAt(4));
+  }
+
+  private static String fileName(String path) {
+    int fileNameStart = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\')) + 1;
+    return path.substring(fileNameStart);
+  }
+
+}
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/SonarQubePythonFile.java b/python-frontend/src/main/java/org/sonar/plugins/python/SonarQubePythonFile.java
index 658016b3e8..53a7748be2 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/SonarQubePythonFile.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/SonarQubePythonFile.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/DjangoViewInfo.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/DjangoViewInfo.java
new file mode 100644
index 0000000000..4d1e455bf1
--- /dev/null
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/DjangoViewInfo.java
@@ -0,0 +1,45 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.api;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Holds metadata about a Django view function discovered during project analysis.
+ */
+public record DjangoViewInfo(Set urlPatterns) {
+
+  public DjangoViewInfo {
+    // Defensive copy to ensure immutability
+    urlPatterns = Set.copyOf(urlPatterns);
+  }
+
+  public static DjangoViewInfo withoutPatterns() {
+    return new DjangoViewInfo(Set.of());
+  }
+
+  public static DjangoViewInfo withPattern(String urlPattern) {
+    return new DjangoViewInfo(Set.of(urlPattern));
+  }
+
+  public DjangoViewInfo addPattern(String urlPattern) {
+    var newPatterns = new HashSet<>(urlPatterns);
+    newPatterns.add(urlPattern);
+    return new DjangoViewInfo(newPatterns);
+  }
+}
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/IssueLocation.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/IssueLocation.java
index 03ab147cc9..25cc7a594d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/IssueLocation.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/IssueLocation.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/LocationInFile.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/LocationInFile.java
index 76850a9dd0..8a213c663d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/LocationInFile.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/LocationInFile.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/Parser.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/Parser.java
index a80142d6af..10f0935969 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/Parser.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/Parser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/ProjectPythonVersion.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/ProjectPythonVersion.java
index 1b94118add..e00d28628b 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/ProjectPythonVersion.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/ProjectPythonVersion.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCheck.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCheck.java
index 9241bf99d2..1abbee1dcc 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCheck.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCheck.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -26,12 +26,19 @@
 
 public interface PythonCheck extends PythonFileConsumer {
 
+  /**
+   * A named flow of issue locations (reported as a DATA flow so the description is shown in the UI).
+   */
+  record IssueFlow(String description, List locations) {
+  }
+
   class PreciseIssue {
 
     private final PythonCheck check;
     private final IssueLocation primaryLocation;
     private Integer cost;
     private final List secondaryLocations;
+    private final List flows = new ArrayList<>();
     private final List quickFixes = new ArrayList<>();
 
     public PreciseIssue(PythonCheck check, IssueLocation primaryLocation) {
@@ -78,6 +85,15 @@ public List secondaryLocations() {
       return secondaryLocations;
     }
 
+    public PreciseIssue addFlow(String description, List locations) {
+      flows.add(new IssueFlow(description, List.copyOf(locations)));
+      return this;
+    }
+
+    public List flows() {
+      return List.copyOf(flows);
+    }
+
     /**
      * This only makes sense in SonarLint context. Should not be used in custom rules.
      */
@@ -97,6 +113,7 @@ public PythonCheck check() {
 
   enum CheckScope {
     MAIN,
+    TESTS,
     ALL
   }
 
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCustomRuleRepository.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCustomRuleRepository.java
index e72e5f72a2..277805b5bf 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCustomRuleRepository.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCustomRuleRepository.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCustomRuleRepositoryWrapper.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCustomRuleRepositoryWrapper.java
index 1f87e325ca..a1ab0a67e3 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCustomRuleRepositoryWrapper.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonCustomRuleRepositoryWrapper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonFile.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonFile.java
index 9ebe2bbbb9..504e84740d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonFile.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonFile.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonFileConsumer.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonFileConsumer.java
index 3156bf3c15..ca6c4dd10a 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonFileConsumer.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonFileConsumer.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonInputFileContext.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonInputFileContext.java
index e3321c73d2..92041e6fd7 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonInputFileContext.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonInputFileContext.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -74,4 +74,8 @@ public File workingDirectory() {
   public SonarProduct sonarProduct() {
     return sonarProduct;
   }
+
+  protected ProjectLevelSymbolTable projectLevelSymbolTable() {
+    return projectLevelSymbolTable;
+  }
 }
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonLine.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonLine.java
index 36f3c44e85..5b29730a33 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonLine.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonLine.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonSubscriptionCheck.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonSubscriptionCheck.java
index 17b7fce1c4..bd203a5458 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonSubscriptionCheck.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonSubscriptionCheck.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVersionSpecifierParser.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVersionSpecifierParser.java
new file mode 100644
index 0000000000..9c0b60731a
--- /dev/null
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVersionSpecifierParser.java
@@ -0,0 +1,184 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.api;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.sonar.plugins.python.api.PythonVersionUtils.Version;
+
+final class PythonVersionSpecifierParser {
+
+  private static final Pattern VERSION_SPECIFIER_PATTERN = Pattern.compile(
+    "^(<=|>=|==|!=|~=|<|>|\\^)\\s*(\\d+)(?:\\.(\\d+))?(?:\\.(\\d+))?(\\.\\*)?$");
+
+  private PythonVersionSpecifierParser() {
+  }
+
+  static boolean containsVersionSpecifier(String[] versions) {
+    return Arrays.stream(versions)
+      .map(String::trim)
+      .filter(value -> !value.isEmpty())
+      .map(value -> value.charAt(0))
+      .anyMatch(character -> "<>=!~^".indexOf(character) >= 0);
+  }
+
+  static Optional> parse(String[] values) {
+    List specifiers = new ArrayList<>();
+    for (String value : values) {
+      Optional specifier = VersionSpecifier.parse(value.trim());
+      if (specifier.isEmpty()) {
+        return Optional.empty();
+      }
+      specifiers.add(specifier.get());
+    }
+
+    Set matchingVersions = EnumSet.noneOf(Version.class);
+    for (Version version : Version.values()) {
+      if (matchesAll(specifiers, VersionLine.from(version))) {
+        matchingVersions.add(version);
+      }
+    }
+    return Optional.of(matchingVersions);
+  }
+
+  private static boolean matchesAll(List specifiers, VersionLine version) {
+    return specifiers.stream().allMatch(specifier -> specifier.matches(version));
+  }
+
+  private enum SpecifierOperator {
+    LESS_THAN,
+    LESS_THAN_OR_EQUAL,
+    GREATER_THAN,
+    GREATER_THAN_OR_EQUAL,
+    EQUAL,
+    NOT_EQUAL,
+    COMPATIBLE,
+    CARET;
+
+    private static Optional fromString(String value) {
+      return Optional.ofNullable(switch (value) {
+        case "<" -> LESS_THAN;
+        case "<=" -> LESS_THAN_OR_EQUAL;
+        case ">" -> GREATER_THAN;
+        case ">=" -> GREATER_THAN_OR_EQUAL;
+        case "==" -> EQUAL;
+        case "!=" -> NOT_EQUAL;
+        case "~=" -> COMPATIBLE;
+        case "^" -> CARET;
+        default -> null;
+      });
+    }
+  }
+
+  private record VersionSpecifier(
+    SpecifierOperator operator,
+    VersionLine version,
+    int precision,
+    boolean wildcard,
+    Optional upperBound) {
+
+    private static Optional parse(String value) {
+      Matcher matcher = VERSION_SPECIFIER_PATTERN.matcher(value);
+      if (!matcher.matches()) {
+        return Optional.empty();
+      }
+      Optional parsedOperator = SpecifierOperator.fromString(matcher.group(1));
+      if (parsedOperator.isEmpty()) {
+        return Optional.empty();
+      }
+      SpecifierOperator operator = parsedOperator.get();
+      try {
+        int major = Integer.parseInt(matcher.group(2));
+        int minor = matcher.group(3) == null ? 0 : Integer.parseInt(matcher.group(3));
+        int precision;
+        if (matcher.group(4) != null) {
+          precision = 3;
+        } else if (matcher.group(3) != null) {
+          precision = 2;
+        } else {
+          precision = 1;
+        }
+        boolean wildcard = matcher.group(5) != null;
+        boolean wildcardWithUnsupportedOperator = wildcard
+          && operator != SpecifierOperator.EQUAL
+          && operator != SpecifierOperator.NOT_EQUAL;
+        boolean compatibleReleaseWithoutMinor = operator == SpecifierOperator.COMPATIBLE
+          && precision < 2;
+        if (wildcardWithUnsupportedOperator || compatibleReleaseWithoutMinor) {
+          return Optional.empty();
+        }
+        VersionLine version = new VersionLine(major, minor);
+        Optional upperBound = upperBound(operator, major, minor, precision);
+        return Optional.of(new VersionSpecifier(operator, version, precision, wildcard, upperBound));
+      } catch (NumberFormatException e) {
+        return Optional.empty();
+      }
+    }
+
+    private static Optional upperBound(SpecifierOperator operator, int major, int minor, int precision) {
+      if (operator == SpecifierOperator.COMPATIBLE) {
+        // Precision 1 is rejected during parsing, so only minor and patch precision remain.
+        return Optional.of(precision == 2
+          ? new VersionLine(major + 1, 0)
+          : new VersionLine(major, minor + 1));
+      }
+      if (operator == SpecifierOperator.CARET) {
+        return Optional.of(new VersionLine(major + 1, 0));
+      }
+      return Optional.empty();
+    }
+
+    private boolean matches(VersionLine candidate) {
+      int comparison = candidate.compareTo(version);
+      return switch (operator) {
+        case LESS_THAN -> comparison < 0;
+        case LESS_THAN_OR_EQUAL -> comparison <= 0;
+        case GREATER_THAN -> comparison > 0;
+        case GREATER_THAN_OR_EQUAL -> comparison >= 0;
+        case EQUAL -> matchesEquality(candidate);
+        case NOT_EQUAL -> !matchesEquality(candidate);
+        case COMPATIBLE, CARET -> comparison >= 0 && candidate.compareTo(upperBound.orElseThrow()) < 0;
+      };
+    }
+
+    private boolean matchesEquality(VersionLine candidate) {
+      if (wildcard && precision == 1) {
+        return candidate.major() == version.major();
+      }
+      return candidate.major() == version.major() && candidate.minor() == version.minor();
+    }
+  }
+
+  private record VersionLine(int major, int minor) implements Comparable {
+
+    private static VersionLine from(Version version) {
+      return new VersionLine(version.major(), version.minor());
+    }
+
+    @Override
+    public int compareTo(VersionLine other) {
+      int majorComparison = Integer.compare(major, other.major);
+      return majorComparison == 0 ? Integer.compare(minor, other.minor) : majorComparison;
+    }
+  }
+}
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVersionUtils.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVersionUtils.java
index baefa7644a..4ddb927889 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVersionUtils.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVersionUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,8 +16,10 @@
  */
 package org.sonar.plugins.python.api;
 
+import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -113,6 +115,28 @@ public static Set fromStringArray(String[] versions) {
     if (versions.length == 0) {
       return allVersions();
     }
+    if (PythonVersionSpecifierParser.containsVersionSpecifier(versions)) {
+      return fromVersionSpecifiers(versions);
+    }
+    return fromExactVersions(versions);
+  }
+
+  private static Set fromVersionSpecifiers(String[] versions) {
+    String propertyValue = String.join(",", Arrays.stream(versions).map(String::trim).toArray(String[]::new));
+    Optional> parsedVersions = PythonVersionSpecifierParser.parse(versions);
+    if (parsedVersions.isEmpty()) {
+      logErrorMessage(propertyValue);
+      return allVersions();
+    }
+    Set matchingVersions = parsedVersions.get();
+    if (matchingVersions.isEmpty()) {
+      logWarningNoMatchingRange(propertyValue);
+      return allVersions();
+    }
+    return matchingVersions;
+  }
+
+  private static Set fromExactVersions(String[] versions) {
     Set pythonVersions = EnumSet.noneOf(Version.class);
     for (String versionValue : versions) {
       versionValue = versionValue.trim();
@@ -178,7 +202,7 @@ public static boolean areSourcePythonVersionsGreaterOrEqualThan(Set sou
 
   private static void logErrorMessage(String propertyValue) {
     LOG.warn(
-      "Error while parsing value of parameter '{}' ({}). Versions must be specified as MAJOR_VERSION.MINOR_VERSION (e.g. \"3.7, 3.8\")",
+      "Error while parsing value of parameter '{}' ({}). Use comma-separated Python versions (e.g. \"3.10,3.11\") or numeric version specifiers (e.g. \">=3.10,<3.13\").",
       PYTHON_VERSION_KEY,
       propertyValue);
   }
@@ -190,4 +214,8 @@ private static void logWarningGuessVersion(String propertyValue, Version guessed
   private static void logWarningPython2(String propertyValue) {
     LOG.warn("No explicit support for version {}. Support for Python versions prior to 3 is deprecated.", propertyValue);
   }
+
+  private static void logWarningNoMatchingRange(String propertyValue) {
+    LOG.warn("No supported Python version matches version range {}. Analysis will target all supported Python versions.", propertyValue);
+  }
 }
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVisitorCheck.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVisitorCheck.java
index ed2686a32c..ca99ac4964 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVisitorCheck.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVisitorCheck.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVisitorContext.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVisitorContext.java
index 3e00fb1d88..b8a5fc176a 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVisitorContext.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/PythonVisitorContext.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,17 +20,27 @@
 import com.sonar.sslr.api.RecognitionException;
 import java.io.File;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.sonar.api.SonarProduct;
+import org.sonar.plugins.python.PythonTestFileClassifier;
 import org.sonar.plugins.python.api.PythonCheck.PreciseIssue;
 import org.sonar.plugins.python.api.caching.CacheContext;
+import org.sonar.plugins.python.api.cfg.ControlFlowGraph;
 import org.sonar.plugins.python.api.project.configuration.ProjectConfiguration;
+import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.types.v2.ModuleType;
 import org.sonar.python.caching.CacheContextImpl;
+import org.sonar.python.cfg.fixpoint.LiveVariablesAnalysis;
+import org.sonar.python.cfg.fixpoint.ReachingDefinitionsAnalysis;
 import org.sonar.python.semantic.ProjectLevelSymbolTable;
 import org.sonar.python.semantic.SymbolTableBuilder;
 import org.sonar.python.semantic.v2.SymbolTableBuilderV2;
@@ -50,7 +60,13 @@ public class PythonVisitorContext extends PythonInputFileContext {
   private final List issues;
   private final ProjectConfiguration projectConfiguration;
   private final CallGraph callGraph;
+  private final Map cfgMap;
+  private final Map  lvaMap;
+  private final ReachingDefinitionsAnalysis reachingDefinitionsAnalysis;
   private final TypeTable typeTable;
+  private final boolean likelyTestFile;
+
+
 
   private PythonVisitorContext(FileInput rootTree, 
       PythonFile pythonFile, 
@@ -61,20 +77,37 @@ private PythonVisitorContext(FileInput rootTree,
       ProjectConfiguration projectConfiguration,
       ModuleType moduleType,
       CallGraph callGraph,
-      TypeTable typeTable
+      TypeTable typeTable,
+      Map cfgMap,
+      boolean likelyTestFile
     ) {
     super(pythonFile, workingDirectory, cacheContext, sonarProduct, projectLevelSymbolTable);
     this.moduleType = moduleType;
     this.projectConfiguration = projectConfiguration;
     this.callGraph = callGraph;
+    this.cfgMap = cfgMap;
+    this.reachingDefinitionsAnalysis = new ReachingDefinitionsAnalysis(pythonFile);
+    this.lvaMap = new HashMap<>();
     this.rootTree = rootTree;
     this.parsingException = null;
     this.typeTable = typeTable;
     this.typeChecker = new TypeChecker(typeTable);
     this.issues = new ArrayList<>();
+    this.likelyTestFile = likelyTestFile;
   }
 
   public PythonVisitorContext(PythonFile pythonFile, RecognitionException parsingException, SonarProduct sonarProduct) {
+    this(pythonFile, parsingException, sonarProduct, false);
+  }
+
+  /**
+   * Creates a context for a Python file that could not be parsed.
+   * @param pythonFile analyzed Python file
+   * @param parsingException parsing failure
+   * @param sonarProduct analysis product
+   * @param likelyTestFile whether the file was classified as test content before parsing failed
+   */
+  public PythonVisitorContext(PythonFile pythonFile, RecognitionException parsingException, SonarProduct sonarProduct, boolean likelyTestFile) {
     super(pythonFile, null, CacheContextImpl.dummyCache(), sonarProduct, ProjectLevelSymbolTable.empty());
     this.rootTree = null;
     this.parsingException = parsingException;
@@ -82,14 +115,26 @@ public PythonVisitorContext(PythonFile pythonFile, RecognitionException parsingE
     this.typeChecker = new TypeChecker(this.typeTable);
     this.projectConfiguration = new ProjectConfiguration();
     this.callGraph = CallGraph.EMPTY;
+    this.cfgMap = Map.of();
+    this.reachingDefinitionsAnalysis = new ReachingDefinitionsAnalysis(pythonFile);
+    this.lvaMap = new HashMap<>();
     this.issues = new ArrayList<>();
     this.moduleType = null;
+    this.likelyTestFile = likelyTestFile;
   }
 
   public FileInput rootTree() {
     return rootTree;
   }
 
+  /**
+   * Reports whether this file is likely to contain test code.
+   * @return whether the file is likely test content
+   */
+  public boolean isLikelyTestFile() {
+    return likelyTestFile;
+  }
+
   public TypeChecker typeChecker() {
     return typeChecker;
   }
@@ -110,6 +155,10 @@ public List getIssues() {
     return issues;
   }
 
+  public Set valuesAtLocation(Name name) {
+    return reachingDefinitionsAnalysis.valuesAtLocation(name);
+  }
+
   @CheckForNull
   @Beta
   public ModuleType moduleType() {
@@ -124,6 +173,24 @@ public CallGraph callGraph() {
     return callGraph;
   }
 
+  @CheckForNull
+  public ControlFlowGraph cfg(Tree tree) {
+    return cfgMap.get(tree);
+  }
+
+  @CheckForNull
+  public LiveVariablesAnalysis lva(Tree tree){
+    ControlFlowGraph cfg = cfg(tree);
+    if (cfg == null) {
+      return null;
+    }
+    return lvaMap.computeIfAbsent(tree, t -> LiveVariablesAnalysis.analyze(cfg));
+  }
+
+  public Optional getDjangoViewInfo(String fqn) {
+    return projectLevelSymbolTable().getDjangoViewInfo(fqn);
+  }
+
   public static class Builder {
     private final PythonFile pythonFile;
     private final FileInput rootTree;
@@ -137,10 +204,13 @@ public static class Builder {
     private Optional callGraph = Optional.empty();
     private Optional packageName = Optional.empty();
     private Optional moduleType = Optional.empty();
+    private Optional> cfgMap = Optional.empty();
+    private boolean likelyTestFile = false;
 
     public Builder(FileInput rootTree, PythonFile pythonFile) {
       this.rootTree = rootTree;
       this.pythonFile = pythonFile;
+      this.likelyTestFile = PythonTestFileClassifier.hasTestContent(rootTree);
     }
 
     public Builder workingDirectory(@Nullable File workingDirectory) {
@@ -188,16 +258,40 @@ public Builder callGraph(CallGraph callGraph) {
       return this;
     }
 
+    // Allows passing pre-computed CFGs when moduleType is set externally and the builder skips type inference.
+    public Builder cfgMap(Map cfgMap) {
+      this.cfgMap = Optional.of(cfgMap);
+      return this;
+    }
+
+    /**
+     * Sets the test-content classification computed from the scanner input and parsed tree.
+     * @param likelyTestFile whether the file is likely test content
+     * @return this builder
+     */
+    public Builder likelyTestFile(boolean likelyTestFile) {
+      this.likelyTestFile = likelyTestFile;
+      return this;
+    }
+
     public PythonVisitorContext build() {
       var symbolTable = projectLevelSymbolTable.orElseGet(ProjectLevelSymbolTable::empty);
       var pkgName = packageName.orElse("");
       buildSymbols(rootTree, pythonFile, pkgName, symbolTable);
       var finalTypeTable = this.typeTable.orElseGet(() -> new ProjectLevelTypeTable(symbolTable));
-      var mt = moduleType.orElseGet(() -> {
+
+      ModuleType mt;
+      Map finalCfgMap;
+      if (moduleType.isPresent()) {
+        mt = moduleType.get();
+        finalCfgMap = cfgMap.orElse(Map.of());
+      } else {
         var symbolTableBuilderV2 = new SymbolTableBuilderV2(rootTree);
         var symbolTableV2 = symbolTableBuilderV2.build();
-        return new TypeInferenceV2(finalTypeTable, pythonFile, symbolTableV2, pkgName).inferModuleType(rootTree);
-      });
+        var typeInference = new TypeInferenceV2(finalTypeTable, pythonFile, symbolTableV2, pkgName);
+        mt = typeInference.inferModuleType(rootTree);
+        finalCfgMap = typeInference.getCfgMap();
+      }
 
       var finalCallGraph = callGraph.orElseGet(() -> CallGraphCollector.collectCallGraph(rootTree));
 
@@ -211,7 +305,9 @@ public PythonVisitorContext build() {
         projectConfiguration.orElse(new ProjectConfiguration()),
         mt,
         finalCallGraph,
-        finalTypeTable
+        finalTypeTable,
+        finalCfgMap,
+        likelyTestFile
       );
     }
 
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/SonarLintCache.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/SonarLintCache.java
index 0fca919c52..9439bbd975 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/SonarLintCache.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/SonarLintCache.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/SonarLintCacheWrapper.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/SonarLintCacheWrapper.java
index 5135eda9f7..105ba4797d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/SonarLintCacheWrapper.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/SonarLintCacheWrapper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/SubscriptionCheck.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/SubscriptionCheck.java
index d57db61361..a17a1ff3c8 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/SubscriptionCheck.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/SubscriptionCheck.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/SubscriptionContext.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/SubscriptionContext.java
index 273eecd584..8eacbe4ecb 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/SubscriptionContext.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/SubscriptionContext.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,14 +19,19 @@
 import com.google.common.annotations.Beta;
 import java.io.File;
 import java.util.Collection;
+import java.util.Optional;
 import java.util.Set;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.sonar.plugins.python.api.caching.CacheContext;
+import org.sonar.plugins.python.api.cfg.ControlFlowGraph;
 import org.sonar.plugins.python.api.project.configuration.ProjectConfiguration;
 import org.sonar.plugins.python.api.symbols.Symbol;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.Token;
 import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.python.cfg.fixpoint.LiveVariablesAnalysis;
 import org.sonar.python.semantic.v2.callgraph.CallGraph;
 import org.sonar.python.semantic.v2.typetable.TypeTable;
 import org.sonar.python.types.v2.TypeChecker;
@@ -48,6 +53,14 @@ public interface SubscriptionContext {
 
   PythonFile pythonFile();
 
+  /**
+   * Reports whether the current file is likely to contain test code.
+   * @return whether the file is likely test content
+   */
+  default boolean isLikelyTestFile() {
+    return false;
+  }
+
   /**
    * List of Python versions this project is compatible with.
    */
@@ -76,4 +89,17 @@ public interface SubscriptionContext {
   ProjectConfiguration projectConfiguration();
 
   CallGraph callGraph();
+
+  ControlFlowGraph cfg(Tree tree);
+
+  LiveVariablesAnalysis lva(Tree tree);
+
+  Set valuesAtLocation(Name name);
+
+  /**
+   * Returns Django view information for the given fully qualified function name.
+   * @param fqn the fully qualified name of a function
+   * @return Optional containing DjangoViewInfo if the function is a Django view, empty otherwise
+   */
+  Optional getDjangoViewInfo(String fqn);
 }
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/TokenLocation.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/TokenLocation.java
index 8d07dbf74c..da864795e5 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/TokenLocation.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/TokenLocation.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/TriBool.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/TriBool.java
index f1477a2574..e1bd102405 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/TriBool.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/TriBool.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/CacheContext.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/CacheContext.java
index 13f2a6cbdb..cd8050d98e 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/CacheContext.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/CacheContext.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/PythonReadCache.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/PythonReadCache.java
index 0c3458baad..3218116d1f 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/PythonReadCache.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/PythonReadCache.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/PythonWriteCache.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/PythonWriteCache.java
index 23a05a0d76..699497c313 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/PythonWriteCache.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/PythonWriteCache.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/package-info.java
index 634b68b7de..e09392d3a4 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/caching/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/CfgBlock.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/CfgBlock.java
index 2b69f3af41..62548855a7 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/CfgBlock.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/CfgBlock.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/CfgBranchingBlock.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/CfgBranchingBlock.java
index 9689b80f7b..f1f52de4c1 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/CfgBranchingBlock.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/CfgBranchingBlock.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/ControlFlowGraph.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/ControlFlowGraph.java
index c816e74c92..9e1bd836d7 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/ControlFlowGraph.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/ControlFlowGraph.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/package-info.java
index 72ff14269e..022a3dd4f1 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/cfg/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/internal/EndOfAnalysis.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/internal/EndOfAnalysis.java
index b923717a4a..ec8de4fe5f 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/internal/EndOfAnalysis.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/internal/EndOfAnalysis.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/internal/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/internal/package-info.java
index ec6ba03c90..c4c7f77c0d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/internal/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/internal/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/NoSonarInfoParser.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/NoSonarInfoParser.java
index e42ed8d38b..507f884a50 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/NoSonarInfoParser.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/NoSonarInfoParser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -33,20 +33,24 @@ public class NoSonarInfoParser {
   private static final String NOQA_PATTERN_REGEX = "^#\\s*noqa(?::\\s*(.+))?(?:[\\s;:].*)?";
   private static final String NOSONAR_PREFIX_REGEX = "^#\\s*NOSONAR(\\W.*)?";
   private static final String NOSONAR_PATTERN_REGEX = "^#\\s*NOSONAR(?:\\s*\\(([^)]*)\\))?($|\\s.*)";
+  private static final String NOSEC_PATTERN_REGEX = "(?i)^#\\s*nosec\\b[:\\s]*(.*)";
+  private static final String NOSEC_RULE_KEY_REGEX = "^[A-Za-z]\\d+$";
   private static final String RULE_KEY_PATTERN_REGEX = "^[a-zA-Z0-9]+$";
 
   private final Pattern noSonarPattern;
   private final Pattern noQaPattern;
+  private final Pattern noSecPattern;
 
   public NoSonarInfoParser() {
     noSonarPattern = Pattern.compile(NOSONAR_PATTERN_REGEX);
     noQaPattern = Pattern.compile(NOQA_PATTERN_REGEX);
+    noSecPattern = Pattern.compile(NOSEC_PATTERN_REGEX);
   }
 
   public boolean isInvalidIssueSuppressionComment(String commentsLine) {
     return splitInlineComments(commentsLine)
       .stream()
-      .anyMatch(comment -> isInvalidNoSonarComment(comment) || isInvalidNoQaComment(comment));
+      .anyMatch(comment -> isInvalidNoSonarComment(comment) || isInvalidNoQaComment(comment) || isInvalidNoSecComment(comment));
   }
 
   private boolean isInvalidNoSonarComment(String comment) {
@@ -86,6 +90,20 @@ private boolean isInvalidNoQaComment(String comment) {
     return !rules.isEmpty() && rules.stream().anyMatch(r -> r.isBlank() || r.contains(" "));
   }
 
+  private boolean isInvalidNoSecComment(String comment) {
+    if (!isValidNoSec(comment)) {
+      return false;
+    }
+    var args = getParamsString(noSecPattern, comment);
+    if (!args.contains(",")) {
+      return false;
+    }
+    var tokens = parseSuppressionRules(args);
+    // Only flag when the args look like a rule list (>=1 rule-shape token); free-form reasons with commas stay valid.
+    var ruleKeys = tokens.stream().filter(t -> t.matches(NOSEC_RULE_KEY_REGEX)).toList();
+    return !ruleKeys.isEmpty() && ruleKeys.size() != tokens.size();
+  }
+
   private static boolean isValidNoSonar(String noSonarCommentLine) {
     return noSonarCommentLine.matches(NOSONAR_PATTERN_REGEX);
   }
@@ -94,27 +112,41 @@ public static boolean isValidNoQa(String noSonarCommentLine) {
     return noSonarCommentLine.matches(NOQA_PATTERN_REGEX);
   }
 
+  public static boolean isValidNoSec(String commentLine) {
+    return commentLine.matches(NOSEC_PATTERN_REGEX);
+  }
+
   public Optional parse(String commentLine) {
     var rules = new HashSet();
-    StringBuilder concatenatedCommentBuilder = new StringBuilder();
+    var concatenatedCommentBuilder = new StringBuilder();
+    var hasSecurityOnlyNosec = false;
     var comments = splitInlineComments(commentLine);
     for (var comment : comments) {
       var noSonarLineInfo = parseComment(comment);
 
       if (noSonarLineInfo != null) {
-        if (noSonarLineInfo.isSuppressedRuleKeysEmpty()) {
+        if (noSonarLineInfo.isSuppressedRuleKeysEmpty() && !noSonarLineInfo.securityOnlySuppression()) {
+          // bare NOSONAR or bare noqa → suppress all rules on this line
           return Optional.of(noSonarLineInfo);
+        } else if (noSonarLineInfo.securityOnlySuppression() && noSonarLineInfo.isSuppressedRuleKeysEmpty()) {
+          // bare nosec → security-only suppression; continue to process remaining comments
+          hasSecurityOnlyNosec = true;
+          concatenatedCommentBuilder.append(noSonarLineInfo.comment());
+        } else {
+          rules.addAll(noSonarLineInfo.suppressedRuleKeys());
+          concatenatedCommentBuilder.append(noSonarLineInfo.comment());
         }
-        rules.addAll(noSonarLineInfo.suppressedRuleKeys());
-        concatenatedCommentBuilder.append(noSonarLineInfo.comment());
       } else {
         concatenatedCommentBuilder.append(comment.strip());
       }
     }
     if (rules.isEmpty()) {
+      if (hasSecurityOnlyNosec) {
+        return Optional.of(NoSonarLineInfo.securityOnly(concatenatedCommentBuilder.toString()));
+      }
       return Optional.empty();
     }
-    return Optional.of(new NoSonarLineInfo(rules, concatenatedCommentBuilder.toString()));
+    return Optional.of(new NoSonarLineInfo(rules, concatenatedCommentBuilder.toString(), hasSecurityOnlyNosec));
   }
 
   @CheckForNull
@@ -132,13 +164,21 @@ private NoSonarLineInfo parseComment(String commentLine) {
         .filter(Predicate.not(String::isEmpty))
         .forEach(rules::add);
       comment = parseNoQaComment(commentLine);
+    } else if (isValidNoSec(commentLine)) {
+      var noSecRules = parseNoSecRules(commentLine);
+      if (noSecRules.isEmpty()) {
+        comment = parseNoSecComment(commentLine);
+        return NoSonarLineInfo.securityOnly(comment);
+      } else {
+        rules.addAll(noSecRules);
+      }
     } else {
       return null;
     }
     return new NoSonarLineInfo(rules, comment);
   }
 
-  private static List splitInlineComments(String commentsLine) {
+  public static List splitInlineComments(String commentsLine) {
     return Stream.of(commentsLine.split("#"))
       .filter(Predicate.not(String::isBlank))
       .map(s -> "#" + s)
@@ -155,7 +195,21 @@ private String parseNoSonarComment(String noSonarCommentLine) {
   }
 
   private List parseNoQaRules(String noSonarCommentLine) {
-    var paramsString = getParamsString(noQaPattern, noSonarCommentLine);
+    return parseSuppressionRules(getParamsString(noQaPattern, noSonarCommentLine));
+  }
+
+  private String parseNoQaComment(String noSonarCommentLine) {
+    return getTruncatedCommentString(noQaPattern, noSonarCommentLine).strip();
+  }
+
+  private List parseNoSecRules(String noSecCommentLine) {
+    return parseSuppressionRules(getParamsString(noSecPattern, noSecCommentLine))
+      .stream()
+      .filter(t -> t.matches(NOSEC_RULE_KEY_REGEX))
+      .toList();
+  }
+
+  private static List parseSuppressionRules(String paramsString) {
     var paramsList = parseParamsString(paramsString).collect(Collectors.toList());
     if (!paramsList.isEmpty()) {
       // to get the last suppressed rule ID we need to split it to cut the trailing comment text.
@@ -170,8 +224,10 @@ private List parseNoQaRules(String noSonarCommentLine) {
     return paramsList;
   }
 
-  private String parseNoQaComment(String noSonarCommentLine) {
-    return getTruncatedCommentString(noQaPattern, noSonarCommentLine).strip();
+  private String parseNoSecComment(String noSecCommentLine) {
+    var raw = getPatternGroup(1, noSecPattern, noSecCommentLine);
+    var truncated = raw.length() > MAX_COMMENT_LENGTH ? raw.substring(0, MAX_COMMENT_LENGTH) : raw;
+    return truncated.strip();
   }
 
   private static String getParamsString(Pattern pattern, String noSonarCommentLine) {
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/NoSonarLineInfo.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/NoSonarLineInfo.java
index 7579a5899d..79ac31af1a 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/NoSonarLineInfo.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/NoSonarLineInfo.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,9 +18,21 @@
 
 import java.util.Set;
 
-public record NoSonarLineInfo(Set suppressedRuleKeys, String comment) {
+public record NoSonarLineInfo(Set suppressedRuleKeys, String comment, boolean securityOnlySuppression) {
   public NoSonarLineInfo(Set suppressedRuleKeys) {
-    this(suppressedRuleKeys, "");
+    this(suppressedRuleKeys, "", false);
+  }
+
+  public NoSonarLineInfo(Set suppressedRuleKeys, String comment) {
+    this(suppressedRuleKeys, comment, false);
+  }
+
+  public static NoSonarLineInfo securityOnly(String comment) {
+    return new NoSonarLineInfo(Set.of(), comment, true);
+  }
+
+  public static NoSonarLineInfo securityOnly() {
+    return securityOnly("");
   }
 
   public boolean isSuppressedRuleKeysEmpty() {
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/package-info.java
index fde7af53fb..889c4e46e7 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/nosonar/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/package-info.java
index 719b8014ec..34619e088f 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/AwsLambdaHandlerInfo.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/AwsLambdaHandlerInfo.java
index 17b0dc11cf..477b7a1950 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/AwsLambdaHandlerInfo.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/AwsLambdaHandlerInfo.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/AwsProjectConfiguration.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/AwsProjectConfiguration.java
index f86d9bad9a..afcaf89948 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/AwsProjectConfiguration.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/AwsProjectConfiguration.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/ProjectConfiguration.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/ProjectConfiguration.java
index 3ef0c84214..5c9f35a9ec 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/ProjectConfiguration.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/ProjectConfiguration.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/package-info.java
index 77d2b49f0a..3ea7927aab 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/project/configuration/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/PythonQuickFix.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/PythonQuickFix.java
index 53e4da5931..638d84186d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/PythonQuickFix.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/PythonQuickFix.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/PythonTextEdit.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/PythonTextEdit.java
index 9f16594286..8c72962c27 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/PythonTextEdit.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/PythonTextEdit.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/package-info.java
index d816d18915..490b14d505 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/quickfix/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/AmbiguousSymbol.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/AmbiguousSymbol.java
index 26da804194..e714420c84 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/AmbiguousSymbol.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/AmbiguousSymbol.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/ClassSymbol.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/ClassSymbol.java
index 3af2dd0c5a..a5deb6f1db 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/ClassSymbol.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/ClassSymbol.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/FunctionSymbol.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/FunctionSymbol.java
index f35004eccb..59f10752a3 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/FunctionSymbol.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/FunctionSymbol.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/Symbol.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/Symbol.java
index 450fa42c69..8b8749e945 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/Symbol.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/Symbol.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/Usage.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/Usage.java
index 1cf9dfafcc..2c315a4876 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/Usage.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/Usage.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/package-info.java
index 999d5c085e..6941e73895 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/SymbolV2.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/SymbolV2.java
index d2cad504cb..ce6f8096cc 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/SymbolV2.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/SymbolV2.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/UsageV2.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/UsageV2.java
index 9a24e6bc9f..02db235a19 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/UsageV2.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/UsageV2.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/package-info.java
index 96727be3d8..bc50928aa7 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/symbols/v2/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AliasedName.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AliasedName.java
index 795d7b754d..e6f64ab1ec 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AliasedName.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AliasedName.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AnnotatedAssignment.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AnnotatedAssignment.java
index 5245c24ef7..ef42d7aead 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AnnotatedAssignment.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AnnotatedAssignment.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AnyParameter.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AnyParameter.java
index 7c16977bed..1a968dc030 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AnyParameter.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AnyParameter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ArgList.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ArgList.java
index c341afc1dd..c8097c24f0 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ArgList.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ArgList.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Argument.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Argument.java
index 8f74fa3b0c..9c52238d26 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Argument.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Argument.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AsPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AsPattern.java
index 80889fd646..8fe90cb074 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AsPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AsPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssertStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssertStatement.java
index 63cc82a4f0..28d72d56a5 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssertStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssertStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssignmentExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssignmentExpression.java
index bc45a915b7..fd6f4729e3 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssignmentExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssignmentExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssignmentStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssignmentStatement.java
index 1d8dcd6045..ec893718e8 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssignmentStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AssignmentStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AwaitExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AwaitExpression.java
index e6729b51b1..22621af1d8 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AwaitExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/AwaitExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BaseTreeVisitor.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BaseTreeVisitor.java
index 9e371b8586..409b940c51 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BaseTreeVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BaseTreeVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BinaryExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BinaryExpression.java
index 35aa2c53da..0ba03e8841 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BinaryExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BinaryExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BreakStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BreakStatement.java
index 18f789e237..59382c0f17 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BreakStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BreakStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CallExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CallExpression.java
index a79944cc2d..77ef1f6015 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CallExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CallExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CapturePattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CapturePattern.java
index c38ef3dabe..34610a1479 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CapturePattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CapturePattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CaseBlock.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CaseBlock.java
index bf72157e2b..2b758e70cd 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CaseBlock.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CaseBlock.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CellMagicStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CellMagicStatement.java
index e25b82d8c9..13883629c0 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CellMagicStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CellMagicStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ClassDef.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ClassDef.java
index 26af308d96..1b63137978 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ClassDef.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ClassDef.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ClassPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ClassPattern.java
index 69038f30f0..6dc9bfc40e 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ClassPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ClassPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CompoundAssignmentStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CompoundAssignmentStatement.java
index 3ea55ce633..8b510d7300 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CompoundAssignmentStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/CompoundAssignmentStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionClause.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionClause.java
index c80bb96503..f144d259c6 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionClause.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionClause.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionExpression.java
index 4829095ae8..9e16230b53 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionFor.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionFor.java
index 12bb3a2c7a..dd7c2a47f8 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionFor.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionFor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionIf.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionIf.java
index 7e45428f5d..bde5b16a8f 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionIf.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ComprehensionIf.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ConditionalExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ConditionalExpression.java
index f688578e96..7733fe1ab4 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ConditionalExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ConditionalExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ContinueStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ContinueStatement.java
index 3384b898d7..bdded74387 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ContinueStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ContinueStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Decorator.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Decorator.java
index ea05ce6255..538a39206c 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Decorator.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Decorator.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DelStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DelStatement.java
index a4cc5ed8b1..a59a57da8d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DelStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DelStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictCompExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictCompExpression.java
index 66eb196c64..c3d2eee041 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictCompExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictCompExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictionaryLiteral.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictionaryLiteral.java
index 17f55a1ac7..2ebe1e1bfa 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictionaryLiteral.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictionaryLiteral.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictionaryLiteralElement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictionaryLiteralElement.java
index 17b565c7f2..e4ceff404e 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictionaryLiteralElement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DictionaryLiteralElement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DottedName.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DottedName.java
index 301260b63c..f5de34a738 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DottedName.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DottedName.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DoubleStarPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DoubleStarPattern.java
index 52d0e7dc8e..8135250414 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DoubleStarPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DoubleStarPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DynamicObjectInfoStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DynamicObjectInfoStatement.java
index a3138167d8..2543bd5ee3 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DynamicObjectInfoStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/DynamicObjectInfoStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/EllipsisExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/EllipsisExpression.java
index 12dd3807aa..82e4f41039 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/EllipsisExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/EllipsisExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ElseClause.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ElseClause.java
index ff0697c3d5..b231bd5468 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ElseClause.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ElseClause.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExceptClause.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExceptClause.java
index f5d3adea3f..99a1354b8a 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExceptClause.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExceptClause.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExecStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExecStatement.java
index 8d7efe4a35..b9a2dd0eb2 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExecStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExecStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Expression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Expression.java
index 305755d82c..1b157b2001 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Expression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Expression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExpressionList.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExpressionList.java
index 3b818a7c8b..0d754ac139 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExpressionList.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExpressionList.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExpressionStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExpressionStatement.java
index 3e4f4ccfd7..8b8129800b 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExpressionStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ExpressionStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FileInput.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FileInput.java
index f105c1f818..c400c662d8 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FileInput.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FileInput.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FinallyClause.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FinallyClause.java
index cd26f707ab..6617fd1ad9 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FinallyClause.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FinallyClause.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ForStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ForStatement.java
index 208e7807f8..21ef5d7a22 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ForStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ForStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FormatSpecifier.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FormatSpecifier.java
index 608689ee0e..de0c35d3c9 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FormatSpecifier.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FormatSpecifier.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FormattedExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FormattedExpression.java
index 45bd67e88a..56e2bb87ee 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FormattedExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FormattedExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FunctionDef.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FunctionDef.java
index 686a17f8d4..bd738544b6 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FunctionDef.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FunctionDef.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FunctionLike.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FunctionLike.java
index 6d3d25a2fc..ec30829bed 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FunctionLike.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/FunctionLike.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/GlobalStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/GlobalStatement.java
index 3628e39bad..d914993f24 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/GlobalStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/GlobalStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/GroupPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/GroupPattern.java
index ce528ff284..ab6fec9ed2 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/GroupPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/GroupPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Guard.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Guard.java
index ee37714d26..921592f739 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Guard.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Guard.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/HasSymbol.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/HasSymbol.java
index ec1275fca5..054aaa6b1b 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/HasSymbol.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/HasSymbol.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/IfStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/IfStatement.java
index 42ab3b3c3e..384986a250 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/IfStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/IfStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportFrom.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportFrom.java
index ab33e5288d..54ad87a37a 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportFrom.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportFrom.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportName.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportName.java
index fb3edd17f4..a0fc26738b 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportName.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportName.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportStatement.java
index 5cd769376b..8c70c02d0c 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ImportStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/InExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/InExpression.java
index b98af33d32..ba5d0a8468 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/InExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/InExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/IsExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/IsExpression.java
index c41650b1c1..d7be5e54e7 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/IsExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/IsExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeyValuePair.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeyValuePair.java
index 827298519c..8aff50e2c7 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeyValuePair.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeyValuePair.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeyValuePattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeyValuePattern.java
index 33ed14a742..07f1dc3a07 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeyValuePattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeyValuePattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeywordPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeywordPattern.java
index fb204ef0ef..f898f4eac0 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeywordPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/KeywordPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LambdaExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LambdaExpression.java
index 321fc41ec5..091a539c74 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LambdaExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LambdaExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LineMagic.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LineMagic.java
index 6726c6fe4e..4820a7684a 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LineMagic.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LineMagic.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ListLiteral.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ListLiteral.java
index f723d59132..78153a7c03 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ListLiteral.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ListLiteral.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LiteralPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LiteralPattern.java
index 66a2304308..2f41e91262 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LiteralPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/LiteralPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/MappingPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/MappingPattern.java
index 1bfdb5a163..24ec35cca0 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/MappingPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/MappingPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/MatchStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/MatchStatement.java
index 5ec06503ef..c45e98b94f 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/MatchStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/MatchStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Name.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Name.java
index 80a7afd53a..e9c83d82f8 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Name.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Name.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NoneExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NoneExpression.java
index fff8577667..abfa36d8d4 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NoneExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NoneExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NonlocalStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NonlocalStatement.java
index c7e0511201..5ff05b9453 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NonlocalStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NonlocalStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NumericLiteral.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NumericLiteral.java
index e44d762ef4..26b361c89d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NumericLiteral.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/NumericLiteral.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/OrPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/OrPattern.java
index 0f27167a23..d81c200448 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/OrPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/OrPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Parameter.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Parameter.java
index 6b76e88355..77d61d7e9c 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Parameter.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Parameter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ParameterList.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ParameterList.java
index 8e4db94b80..27aab460f8 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ParameterList.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ParameterList.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ParenthesizedExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ParenthesizedExpression.java
index f547e18e2b..873eb16c1a 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ParenthesizedExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ParenthesizedExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/PassStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/PassStatement.java
index 0f798760db..331ba7dd5e 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/PassStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/PassStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Pattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Pattern.java
index e1db9352b4..99b38859ea 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Pattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Pattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/PrintStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/PrintStatement.java
index f0d6039080..2959aac1e9 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/PrintStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/PrintStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/QualifiedExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/QualifiedExpression.java
index 54b4addad0..9211e92095 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/QualifiedExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/QualifiedExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/RaiseStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/RaiseStatement.java
index 4e80f58260..b8d09ead7b 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/RaiseStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/RaiseStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/RegularArgument.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/RegularArgument.java
index 698c21772d..d7baba1708 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/RegularArgument.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/RegularArgument.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ReprExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ReprExpression.java
index a2fe9f34d0..fde9c9a627 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ReprExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ReprExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ReturnStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ReturnStatement.java
index 4c103fb3a1..34a2323502 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ReturnStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ReturnStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SequencePattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SequencePattern.java
index ab81158524..826cfd3c5a 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SequencePattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SequencePattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SetLiteral.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SetLiteral.java
index e273b4355e..2353df52f4 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SetLiteral.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SetLiteral.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceExpression.java
index 33eacfe0c9..a06146db64 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceItem.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceItem.java
index fc80cf1863..fd17817810 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceItem.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceItem.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceList.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceList.java
index f767b32e49..b1d67134a9 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceList.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SliceList.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StarPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StarPattern.java
index cdb6a142d9..920e975014 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StarPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StarPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Statement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Statement.java
index 0f556ccc1e..41ed9546e5 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Statement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Statement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StatementList.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StatementList.java
index 5703d06f87..851ff0e043 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StatementList.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StatementList.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StringElement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StringElement.java
index 78167826b5..c24fea3adc 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StringElement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StringElement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StringLiteral.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StringLiteral.java
index 33ee9d5180..82e1950803 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StringLiteral.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/StringLiteral.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SubscriptionExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SubscriptionExpression.java
index d44108c0ca..91f9a95005 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SubscriptionExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/SubscriptionExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Token.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Token.java
index 0740b1a2a7..032f4deef9 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Token.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Token.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Tree.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Tree.java
index a7ca7c186b..8076460e84 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Tree.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Tree.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TreeVisitor.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TreeVisitor.java
index 7cb1dc0703..5c355a6376 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TreeVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TreeVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Trivia.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Trivia.java
index 0f147676c4..315bd1ae57 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Trivia.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Trivia.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TryStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TryStatement.java
index 822458593f..f3a3b0f493 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TryStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TryStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Tuple.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Tuple.java
index 203a77820c..a9236389f6 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Tuple.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Tuple.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TupleParameter.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TupleParameter.java
index 91c102bd6e..9373c99da4 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TupleParameter.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TupleParameter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeAliasStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeAliasStatement.java
index 822a6c1bdf..d480796ea3 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeAliasStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeAliasStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeAnnotation.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeAnnotation.java
index 82f6dbb1bf..53b216f42f 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeAnnotation.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeAnnotation.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeParam.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeParam.java
index d87d0a3cb8..83f3d9e7c8 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeParam.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeParam.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeParams.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeParams.java
index 6eaaf86fe2..37e1fea846 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeParams.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TypeParams.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/UnaryExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/UnaryExpression.java
index b87fe8947f..2a6c1a2d74 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/UnaryExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/UnaryExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/UnpackingExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/UnpackingExpression.java
index 739eda049b..0f96cbebb9 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/UnpackingExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/UnpackingExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ValuePattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ValuePattern.java
index 8568942370..76b3c48deb 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ValuePattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ValuePattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WhileStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WhileStatement.java
index 7cbce07635..d8b67d4157 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WhileStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WhileStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WildcardPattern.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WildcardPattern.java
index a18dee4505..c5917b4c9f 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WildcardPattern.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WildcardPattern.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WithItem.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WithItem.java
index aee6006da8..ec569e9f8f 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WithItem.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WithItem.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WithStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WithStatement.java
index b9b5b31a5c..987c626e68 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WithStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/WithStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/YieldExpression.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/YieldExpression.java
index f4fe99a720..ccbece91c3 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/YieldExpression.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/YieldExpression.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/YieldStatement.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/YieldStatement.java
index df84117586..8487930f16 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/YieldStatement.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/YieldStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/package-info.java
index 270976290f..7a1f8f4507 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/tree/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/BuiltinTypes.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/BuiltinTypes.java
index e6f3e466c3..242a4e7cdb 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/BuiltinTypes.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/BuiltinTypes.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -27,6 +27,7 @@ public class BuiltinTypes {
   public static final String TUPLE = "tuple";
   public static final String LIST = "list";
   public static final String SET = "set";
+  public static final String FROZENSET = "frozenset";
   public static final String DICT = "dict";
 
   // https://docs.python.org/3/library/stdtypes.html#bytes-objects
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/InferredType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/InferredType.java
index 0d38917b53..5af31cc0ea 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/InferredType.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/InferredType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/package-info.java
index 561d456c30..202a5773e2 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ClassType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ClassType.java
index 686ba2ebca..a9ed197ce4 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ClassType.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ClassType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -147,7 +147,7 @@ private Optional resolveMember(String memberName, Set vi
       .or(() -> inheritedMember(memberName, visited));
   }
 
-  private Optional localMember(String memberName) {
+  Optional localMember(String memberName) {
     return members.stream()
       .filter(m -> m.name().equals(memberName))
       .map(Member::type)
@@ -184,6 +184,54 @@ public boolean hasUnresolvedHierarchy() {
     );
   }
 
+  /**
+   * Computes the C3 linearization (Method Resolution Order) for this class.
+   *
+   * 
                  Returns {@code Optional.empty()} if:
+   * 
                    
+   *   
                  • the type hierarchy is unresolved ({@link #hasUnresolvedHierarchy()} is {@code true}), or
                    • 
+   *   
                  • the MRO cannot be computed because the base class ordering creates a conflict
+   *       (i.e. what Python raises as a {@code TypeError} at class definition time).
                    • 
+   * 
                  
+   *
+   * 
                  The returned list starts with {@code this} and ends with the most-distant ancestor.
+   *
+   * @see Python MRO documentation
+   */
+  public Optional> mro() {
+    if (hasUnresolvedHierarchy()) {
+      return Optional.empty();
+    }
+    return ClassTypeMroUtils.compute(this);
+  }
+
+  /**
+   * Returns whether C3 linearization would succeed at runtime for a hypothetical class whose direct
+   * bases are exactly {@code bases} in order. Uses Python's runtime view of built-in containers:
+   * typeshed-only inheritance edges from {@code dict}/{@code list}/{@code set}/… to their
+   * {@code collections.abc} / {@code typing} ABCs (which at runtime are
+   * {@code abc.ABCMeta.register()} virtual subclasses, not real bases) are ignored. This way, valid
+   * Python code such as {@code class N(MutableMapping, dict): pass} is not flagged.
+   *
+   * 
                  Precondition: every element of {@code bases} is non-null and fully resolved (no unresolved
+   * hierarchy), matching what {@link #mro()} requires for each base.
+   *
+   * 
                  If any base has an empty {@link #mro()} because an ancestor's hierarchy is invalid, this
+   * returns {@code true} — the failure is not attributable to the merge of these bases alone.
+   */
+  public static boolean wouldHaveValidMro(List bases) {
+    return ClassTypeMroUtils.wouldHaveValidMro(bases);
+  }
+
+  /**
+   * Returns {@code true} for built-in containers whose typeshed declaration includes fictional
+   * ABC inheritance that does not exist at runtime (e.g. {@code dict}, {@code list}, {@code set}).
+   * See {@link #wouldHaveValidMro(List)}.
+   */
+  public boolean isVirtualAbcSubclassingBuiltin() {
+    return ClassTypeMroUtils.isVirtualAbcSubclassingBuiltin(this);
+  }
+
   @Override
   public TriBool hasMember(String memberName) {
     // a ClassType is an object of class type, it has the same members as those present on any type
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ClassTypeMroUtils.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ClassTypeMroUtils.java
new file mode 100644
index 0000000000..a38b006e54
--- /dev/null
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ClassTypeMroUtils.java
@@ -0,0 +1,185 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.api.types.v2;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import javax.annotation.CheckForNull;
+
+/**
+ * C3 linearization (Method Resolution Order) for {@link ClassType}.
+ *
+ * 
                  Built-in containers listed in {@link #VIRTUAL_ABC_SUBCLASSING_BUILTIN_FQNS} have typeshed
+ * declarations that lie about their bases (e.g. {@code class dict(MutableMapping, Generic)}),
+ * but at runtime they only inherit from {@code object} and the ABC relationship is a
+ * virtual-subclass registration via {@code abc.ABCMeta.register()}. {@link #compute(ClassType)}
+ * preserves the typeshed view (used by {@link ClassType#mro()}), while
+ * {@link #wouldHaveValidMro(List)} honours the runtime view (used to detect real MRO conflicts).
+ */
+final class ClassTypeMroUtils {
+
+  private static final Set VIRTUAL_ABC_SUBCLASSING_BUILTIN_FQNS = Set.of(
+    "dict", "list", "tuple", "set", "frozenset", "str", "bytes", "bytearray", "collections.deque"
+  );
+
+  private ClassTypeMroUtils() {
+  }
+
+  static Optional> compute(ClassType cls) {
+    return compute(cls, new HashMap<>(), new HashSet<>(), false);
+  }
+
+  /**
+   * Returns whether C3 would succeed at runtime for a hypothetical class whose direct bases are
+   * exactly {@code bases} in order. Backs {@link ClassType#wouldHaveValidMro(List)}.
+   */
+  static boolean wouldHaveValidMro(List bases) {
+    Map>> cache = new HashMap<>();
+    List> lists = new ArrayList<>();
+    for (ClassType base : bases) {
+      Optional> mro = compute(base, cache, new HashSet<>(), true);
+      if (mro.isEmpty()) {
+        return true;
+      }
+      lists.add(new ArrayList<>(mro.get()));
+    }
+    lists.add(new ArrayList<>(bases));
+    return c3Merge(lists) != null;
+  }
+
+  static boolean isVirtualAbcSubclassingBuiltin(ClassType cls) {
+    String fqn = cls.fullyQualifiedName();
+    return fqn != null && VIRTUAL_ABC_SUBCLASSING_BUILTIN_FQNS.contains(fqn);
+  }
+
+  /**
+   * Recursively computes the C3 MRO for {@code cls}. {@code cache} memoises results across the
+   * traversal (callers may pass a fresh map); {@code visiting} guards against inheritance cycles.
+   */
+  private static Optional> compute(
+    ClassType cls,
+    Map>> cache,
+    Set visiting,
+    boolean stripVirtualAbcInheritance
+  ) {
+    if (cache.containsKey(cls)) {
+      return cache.get(cls);
+    }
+    if (stripVirtualAbcInheritance && isVirtualAbcSubclassingBuiltin(cls)) {
+      // Runtime view: ignore the typeshed-declared parents but still keep {@code object} as the tail,
+      // so C3 rejects orderings like {@code class X(object, dict)} (object must come after dict).
+      // {@code object} is, by construction, the last element of {@code cls}'s non-stripped MRO.
+      Optional> fullMro = compute(cls, new HashMap<>(), new HashSet<>(), false);
+      List mro = fullMro.map(m -> List.of(cls, m.get(m.size() - 1))).orElseGet(() -> List.of(cls));
+      Optional> result = Optional.of(mro);
+      cache.put(cls, result);
+      return result;
+    }
+    if (!visiting.add(cls)) {
+      // Cycle detected — treat as failure.
+      return Optional.empty();
+    }
+
+    List parentTypes = new ArrayList<>();
+    for (TypeWrapper wrapper : cls.superClasses()) {
+      if (wrapper.type() instanceof ClassType parent) {
+        parentTypes.add(parent);
+      }
+      // Non-ClassType superclass is already filtered out by hasUnresolvedHierarchy()
+    }
+
+    List> lists = new ArrayList<>();
+    for (ClassType parent : parentTypes) {
+      Optional> parentMro = compute(parent, cache, visiting, stripVirtualAbcInheritance);
+      if (parentMro.isEmpty()) {
+        // A parent's MRO is invalid — Python would have raised TypeError there, not here.
+        visiting.remove(cls);
+        cache.put(cls, Optional.empty());
+        return Optional.empty();
+      }
+      lists.add(new ArrayList<>(parentMro.get()));
+    }
+    lists.add(new ArrayList<>(parentTypes));
+
+    List merged = c3Merge(lists);
+    Optional> result;
+    if (merged == null) {
+      result = Optional.empty();
+    } else {
+      merged.add(0, cls);
+      result = Optional.of(merged);
+    }
+
+    visiting.remove(cls);
+    cache.put(cls, result);
+    return result;
+  }
+
+  /** Returns the C3 merge of {@code lists}, or {@code null} if no valid merge exists. */
+  @CheckForNull
+  private static List c3Merge(List> lists) {
+    List result = new ArrayList<>();
+    while (true) {
+      lists.removeIf(List::isEmpty);
+      if (lists.isEmpty()) {
+        return result;
+      }
+      ClassType candidate = findFirstValidMergeHead(lists);
+      if (candidate == null) {
+        return null;
+      }
+      result.add(candidate);
+      removeHeadFromLists(lists, candidate);
+    }
+  }
+
+  /** Returns the first list head that doesn't appear as a non-head in any list, or {@code null}. */
+  @CheckForNull
+  private static ClassType findFirstValidMergeHead(List> lists) {
+    for (List list : lists) {
+      ClassType head = list.get(0);
+      if (!headAppearsAsNonHeadInAnyList(head, lists)) {
+        return head;
+      }
+    }
+    return null;
+  }
+
+  private static boolean headAppearsAsNonHeadInAnyList(ClassType head, List> lists) {
+    for (List other : lists) {
+      for (int k = 1; k < other.size(); k++) {
+        if (other.get(k) == head) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  private static void removeHeadFromLists(List> lists, ClassType chosen) {
+    for (List list : lists) {
+      if (!list.isEmpty() && list.get(0) == chosen) {
+        list.remove(0);
+      }
+    }
+  }
+}
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/FullyQualifiedNameHelper.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/FullyQualifiedNameHelper.java
index 116a6e7eba..cbf27b9f39 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/FullyQualifiedNameHelper.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/FullyQualifiedNameHelper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/FunctionType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/FunctionType.java
index 3746b08480..5175b0c2b9 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/FunctionType.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/FunctionType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/Member.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/Member.java
index 05ee7a1661..ad0053195d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/Member.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/Member.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ModuleType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ModuleType.java
index d96973f35b..2112dbc7bc 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ModuleType.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ModuleType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ObjectType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ObjectType.java
index 34b838dd15..b9df28fcd7 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ObjectType.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ObjectType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ParameterV2.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ParameterV2.java
index 9efdf6799d..96637f61a5 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ParameterV2.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/ParameterV2.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/PythonType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/PythonType.java
index 53b949a0bc..47b85deeeb 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/PythonType.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/PythonType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/SelfType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/SelfType.java
index 8f65a6bb29..5ceb568b97 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/SelfType.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/SelfType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/SuperProxyType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/SuperProxyType.java
new file mode 100644
index 0000000000..a1a02012a1
--- /dev/null
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/SuperProxyType.java
@@ -0,0 +1,48 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.api.types.v2;
+
+import java.util.Optional;
+
+/**
+ * A proxy type returned by zero-argument {@code super()} calls inside a method.
+ * Member lookup delegates to the enclosing class's C3 MRO tail — i.e. the MRO
+ * starting from the first parent (skipping the class itself).
+ */
+public record SuperProxyType(ClassType ownerClassType) implements PythonType {
+
+  // FQN used by the V2 type system for the builtin super class
+  // (builtins prefix is stripped by TypeShedUtils.normalizedFqn)
+  public static final String SUPER_FQN = "super";
+
+  @Override
+  public String name() {
+    return SUPER_FQN;
+  }
+
+  @Override
+  public Optional resolveMember(String memberName) {
+    return ownerClassType.mro()
+      .map(mro -> mro.stream()
+        .skip(1)
+        .map(classType -> classType.localMember(memberName))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
+        .findFirst())
+      .orElse(Optional.empty());
+  }
+}
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeOrigin.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeOrigin.java
index 12a5686f96..a0a5f0e73a 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeOrigin.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeOrigin.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeSource.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeSource.java
index 6b79fd784b..d33d37d51e 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeSource.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeSource.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeWrapper.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeWrapper.java
index 4031470f8f..5337417283 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeWrapper.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/TypeWrapper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/UnionType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/UnionType.java
index f82130f114..297d51b182 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/UnionType.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/UnionType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/UnknownType.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/UnknownType.java
index 8261c66498..7f8dae35b4 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/UnknownType.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/UnknownType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,25 +14,6 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-/*
- * SonarQube Python Plugin
- * Copyright (C) 2011-2024 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
 package org.sonar.plugins.python.api.types.v2;
 
 import java.util.Optional;
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcher.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcher.java
index a99e1bfe21..67ecdd812d 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcher.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcher.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherUtils.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherUtils.java
index c4c9e70d2a..e138afe2ea 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherUtils.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatchers.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatchers.java
index f48ac7ba8a..30d1915835 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatchers.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatchers.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,11 +19,14 @@
 import com.google.common.annotations.VisibleForTesting;
 import java.util.Arrays;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Stream;
+import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.types.v2.TypeSource;
 import org.sonar.python.types.v2.matchers.AllTypePredicate;
 import org.sonar.python.types.v2.matchers.AnyTypePredicate;
 import org.sonar.python.types.v2.matchers.HasFQNPredicate;
+import org.sonar.python.types.v2.matchers.HasFQNSatisfyingPredicate;
 import org.sonar.python.types.v2.matchers.HasMemberPredicate;
 import org.sonar.python.types.v2.matchers.HasMemberSatisfyingPredicate;
 import org.sonar.python.types.v2.matchers.IsFunctionOwnerSatisfyingPredicate;
@@ -82,6 +85,24 @@ public static TypeMatcher withFQN(String fqn) {
     return new TypeMatcherImpl(new HasFQNPredicate(fqn));
   }
 
+  /**
+   * Matches types whose FQN satisfies {@code fqnPredicate}. Prefer {@link #isType(String)} when
+   * stubs exist; FQN-based matching is a fallback for unresolved third-party imports.
+   */
+  public static TypeMatcher withFQNSatisfying(Function fqnPredicate) {
+    return new TypeMatcherImpl(new HasFQNSatisfyingPredicate(fqnPredicate));
+  }
+
+  /**
+   * Matches types whose FQN starts with {@code fqnPrefix}. Prefer a trailing {@code '.'}
+   * (e.g. {@code "numpy."}) so sibling modules like {@code numpyish} are not matched.
+   * Prefer {@link #isType(String)} when stubs exist; FQN-based matching is a fallback for
+   * unresolved third-party imports.
+   */
+  public static TypeMatcher withFQNPrefix(String fqnPrefix) {
+    return withFQNSatisfying(typeFqn -> typeFqn.startsWith(fqnPrefix) ? TriBool.TRUE : TriBool.FALSE);
+  }
+
   public static TypeMatcher isObjectSatisfying(TypeMatcher matcher) {
     TypePredicate predicate = getTypePredicate(matcher);
     return new TypeMatcherImpl(new IsObjectSatisfyingPredicate(predicate));
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/package-info.java
index 92be06f29b..93f6e5a63b 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/matchers/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/package-info.java
index 42f5967b7b..2938e95e87 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/api/types/v2/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/plugins/python/package-info.java b/python-frontend/src/main/java/org/sonar/plugins/python/package-info.java
index 7bd4910cb2..e0e0e606dc 100644
--- a/python-frontend/src/main/java/org/sonar/plugins/python/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/plugins/python/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/DocstringExtractor.java b/python-frontend/src/main/java/org/sonar/python/DocstringExtractor.java
index 3bc220fb57..709ec8edce 100644
--- a/python-frontend/src/main/java/org/sonar/python/DocstringExtractor.java
+++ b/python-frontend/src/main/java/org/sonar/python/DocstringExtractor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/EscapeCharPositionInfo.java b/python-frontend/src/main/java/org/sonar/python/EscapeCharPositionInfo.java
index 2b47ca65ce..c3a5b7d285 100644
--- a/python-frontend/src/main/java/org/sonar/python/EscapeCharPositionInfo.java
+++ b/python-frontend/src/main/java/org/sonar/python/EscapeCharPositionInfo.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/IPythonLocation.java b/python-frontend/src/main/java/org/sonar/python/IPythonLocation.java
index ed2d5a5196..fec2ae2a7f 100644
--- a/python-frontend/src/main/java/org/sonar/python/IPythonLocation.java
+++ b/python-frontend/src/main/java/org/sonar/python/IPythonLocation.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/PythonConfiguration.java b/python-frontend/src/main/java/org/sonar/python/PythonConfiguration.java
index 38c05001f2..de07e40892 100644
--- a/python-frontend/src/main/java/org/sonar/python/PythonConfiguration.java
+++ b/python-frontend/src/main/java/org/sonar/python/PythonConfiguration.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/SubscriptionVisitor.java b/python-frontend/src/main/java/org/sonar/python/SubscriptionVisitor.java
index a870270184..c1aa7de58f 100644
--- a/python-frontend/src/main/java/org/sonar/python/SubscriptionVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/SubscriptionVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -25,10 +25,12 @@
 import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
+import org.sonar.plugins.python.api.DjangoViewInfo;
 import org.sonar.plugins.python.api.IssueLocation;
 import org.sonar.plugins.python.api.LocationInFile;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
@@ -39,13 +41,17 @@
 import org.sonar.plugins.python.api.PythonVisitorContext;
 import org.sonar.plugins.python.api.SubscriptionContext;
 import org.sonar.plugins.python.api.caching.CacheContext;
+import org.sonar.plugins.python.api.cfg.ControlFlowGraph;
 import org.sonar.plugins.python.api.project.configuration.ProjectConfiguration;
 import org.sonar.plugins.python.api.symbols.Symbol;
+import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.StringElement;
 import org.sonar.plugins.python.api.tree.Token;
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.tree.Tree.Kind;
+import org.sonar.python.cfg.fixpoint.LiveVariablesAnalysis;
 import org.sonar.python.regex.PythonAnalyzerRegexSource;
 import org.sonar.python.regex.PythonRegexIssueLocation;
 import org.sonar.python.regex.RegexContext;
@@ -166,6 +172,11 @@ public PythonFile pythonFile() {
       return pythonVisitorContext.pythonFile();
     }
 
+    @Override
+    public boolean isLikelyTestFile() {
+      return pythonVisitorContext.isLikelyTestFile();
+    }
+
     @Override
     public Collection stubFilesSymbols() {
       return pythonVisitorContext.stubFilesSymbols();
@@ -202,10 +213,30 @@ public CallGraph callGraph() {
       return pythonVisitorContext.callGraph();
     }
 
+    @Override
+    public ControlFlowGraph cfg(Tree tree) {
+      return pythonVisitorContext.cfg(tree);
+    }
+
+    @Override
+    public LiveVariablesAnalysis lva(Tree tree) {
+      return pythonVisitorContext.lva(tree);
+    }
+
+    @Override
+    public Set valuesAtLocation(Name name) {
+      return pythonVisitorContext.valuesAtLocation(name);
+    }
+
     @Override
     public RegexParseResult regexForStringElement(StringElement stringElement, FlagSet flagSet) {
       return regexCache.computeIfAbsent(stringElement.hashCode() + "-" + flagSet.getMask(),
         s -> new RegexParser(new PythonAnalyzerRegexSource(stringElement), flagSet).parse());
     }
+
+    @Override
+    public Optional getDjangoViewInfo(String fqn) {
+      return pythonVisitorContext.getDjangoViewInfo(fqn);
+    }
   }
 }
diff --git a/python-frontend/src/main/java/org/sonar/python/TestPythonVisitorRunner.java b/python-frontend/src/main/java/org/sonar/python/TestPythonVisitorRunner.java
index 7a2dc1aa12..1fae2a80c9 100644
--- a/python-frontend/src/main/java/org/sonar/python/TestPythonVisitorRunner.java
+++ b/python-frontend/src/main/java/org/sonar/python/TestPythonVisitorRunner.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,6 +21,7 @@
 import java.net.URI;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import javax.annotation.Nullable;
@@ -89,7 +90,8 @@ public static PythonVisitorContext createContext(File file, @Nullable File worki
     var typeTable = new ProjectLevelTypeTable(projectLevelSymbolTable);
     var symbolTableBuilderV2 = new SymbolTableBuilderV2(rootTree);
     var symbolTableV2 = symbolTableBuilderV2.build();
-    var moduleType = new TypeInferenceV2(typeTable, pythonFile, symbolTableV2, packageName).inferModuleType(rootTree);
+    var typeInference = new TypeInferenceV2(typeTable, pythonFile, symbolTableV2, packageName);
+    var moduleType = typeInference.inferModuleType(rootTree);
 
     if (projectConfiguration == null) {
       var projectConfigurationBuilder = new ProjectConfigurationBuilder();
@@ -105,6 +107,7 @@ public static PythonVisitorContext createContext(File file, @Nullable File worki
       .projectConfiguration(projectConfiguration)
       .typeTable(typeTable)
       .moduleType(moduleType)
+      .cfgMap(typeInference.getCfgMap())
       .build();
   }
 
@@ -131,20 +134,30 @@ public static PythonVisitorContext createNotebookContext(File file, Map files, File baseDir) {
+    return globalSymbols(files, computePackageRoots(files, baseDir));
+  }
+
+  public static ProjectLevelSymbolTable globalSymbols(List files, List packageRoots) {
     ProjectLevelSymbolTable projectLevelSymbolTable = ProjectLevelSymbolTable.empty();
     for (File file : files) {
       var pythonFile = new TestPythonFile(file);
-      String packageName = pythonPackageName(file, baseDir.getAbsolutePath());
+      String packageName = pythonPackageName(file, packageRoots);
       fillSymbolTableWithFile(pythonFile, projectLevelSymbolTable, packageName);
     }
     return projectLevelSymbolTable;
   }
 
   public static ProjectLevelSymbolTable globalSymbols(Map pathToContent, String baseDir) {
+    File baseDirFile = new File(baseDir);
+    List files = pathToContent.keySet().stream().map(path -> new File(baseDir, path)).toList();
+    return globalSymbols(pathToContent, baseDir, computePackageRoots(files, baseDirFile));
+  }
+
+  public static ProjectLevelSymbolTable globalSymbols(Map pathToContent, String baseDir, List packageRoots) {
     ProjectLevelSymbolTable projectLevelSymbolTable = ProjectLevelSymbolTable.empty();
     pathToContent.forEach((path, content) -> {
       var file = new MockPythonFile(baseDir, path, content);
-      var packageName = pythonPackageName(file.file(), baseDir);
+      var packageName = pythonPackageName(file.file(), packageRoots);
       fillSymbolTableWithFile(file, projectLevelSymbolTable, packageName);
     });
     return projectLevelSymbolTable;
@@ -173,6 +186,31 @@ private static FileInput parseFile(TestablePythonFile file) {
     return treeMaker.fileInput(astNode);
   }
 
+  /**
+   * Test-only counterpart of the package-root computation in {@code PackageRootResolver}.
+   * It lives here because python-frontend cannot depend on python-commons, while downstream
+   * test utilities can reuse this class through their existing python-frontend dependency.
+   */
+  public static List computePackageRoots(List files, File baseDir) {
+    String baseDirPath = baseDir.getAbsolutePath();
+    List roots = files.stream()
+      .map(f -> {
+        File current = f.getParentFile();
+        while (current != null && !current.getAbsolutePath().equals(baseDirPath)) {
+          if (!new File(current, "__init__.py").exists()) {
+            break;
+          }
+          current = current.getParentFile();
+        }
+        return current != null ? current.getAbsolutePath() : baseDirPath;
+      })
+      .distinct()
+      .sorted(Comparator.comparingInt((String p) -> (int) p.chars().filter(c -> c == File.separatorChar).count()).reversed()
+        .thenComparing(Comparator.naturalOrder()))
+      .toList();
+    return roots.isEmpty() ? List.of(baseDirPath) : roots;
+  }
+
   interface TestablePythonFile extends PythonFile {
     default boolean isIPython() {
       return fileName().endsWith(".ipynb");
diff --git a/python-frontend/src/main/java/org/sonar/python/api/IPythonGrammar.java b/python-frontend/src/main/java/org/sonar/python/api/IPythonGrammar.java
index 3b93c5a359..a4b3c0cc54 100644
--- a/python-frontend/src/main/java/org/sonar/python/api/IPythonGrammar.java
+++ b/python-frontend/src/main/java/org/sonar/python/api/IPythonGrammar.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/api/IPythonGrammarBuilder.java b/python-frontend/src/main/java/org/sonar/python/api/IPythonGrammarBuilder.java
index 5b07095b00..a904be8e2f 100644
--- a/python-frontend/src/main/java/org/sonar/python/api/IPythonGrammarBuilder.java
+++ b/python-frontend/src/main/java/org/sonar/python/api/IPythonGrammarBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/api/PythonGrammar.java b/python-frontend/src/main/java/org/sonar/python/api/PythonGrammar.java
index 0c497e8664..eb1651e654 100644
--- a/python-frontend/src/main/java/org/sonar/python/api/PythonGrammar.java
+++ b/python-frontend/src/main/java/org/sonar/python/api/PythonGrammar.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/api/PythonGrammarBuilder.java b/python-frontend/src/main/java/org/sonar/python/api/PythonGrammarBuilder.java
index 99551925d4..602037fa24 100644
--- a/python-frontend/src/main/java/org/sonar/python/api/PythonGrammarBuilder.java
+++ b/python-frontend/src/main/java/org/sonar/python/api/PythonGrammarBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/api/PythonKeyword.java b/python-frontend/src/main/java/org/sonar/python/api/PythonKeyword.java
index 2653527a93..29d2856c70 100644
--- a/python-frontend/src/main/java/org/sonar/python/api/PythonKeyword.java
+++ b/python-frontend/src/main/java/org/sonar/python/api/PythonKeyword.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/api/PythonPunctuator.java b/python-frontend/src/main/java/org/sonar/python/api/PythonPunctuator.java
index d6b20dabf3..67ba2941e1 100644
--- a/python-frontend/src/main/java/org/sonar/python/api/PythonPunctuator.java
+++ b/python-frontend/src/main/java/org/sonar/python/api/PythonPunctuator.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/api/PythonTokenType.java b/python-frontend/src/main/java/org/sonar/python/api/PythonTokenType.java
index 394b8de460..9b7b5c1c4a 100644
--- a/python-frontend/src/main/java/org/sonar/python/api/PythonTokenType.java
+++ b/python-frontend/src/main/java/org/sonar/python/api/PythonTokenType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/api/package-info.java b/python-frontend/src/main/java/org/sonar/python/api/package-info.java
index 494861dbad..4821fc77ac 100644
--- a/python-frontend/src/main/java/org/sonar/python/api/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/api/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/caching/CacheContextImpl.java b/python-frontend/src/main/java/org/sonar/python/caching/CacheContextImpl.java
index dbe2b288bc..17c9f1f6b5 100644
--- a/python-frontend/src/main/java/org/sonar/python/caching/CacheContextImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/caching/CacheContextImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/caching/CpdSerializer.java b/python-frontend/src/main/java/org/sonar/python/caching/CpdSerializer.java
index 5bd1130221..5f778fae1d 100644
--- a/python-frontend/src/main/java/org/sonar/python/caching/CpdSerializer.java
+++ b/python-frontend/src/main/java/org/sonar/python/caching/CpdSerializer.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/caching/DummyCache.java b/python-frontend/src/main/java/org/sonar/python/caching/DummyCache.java
index 9edc580507..694a1e7cb0 100644
--- a/python-frontend/src/main/java/org/sonar/python/caching/DummyCache.java
+++ b/python-frontend/src/main/java/org/sonar/python/caching/DummyCache.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/caching/PythonReadCacheImpl.java b/python-frontend/src/main/java/org/sonar/python/caching/PythonReadCacheImpl.java
index 5b90560787..bf4a8113ff 100644
--- a/python-frontend/src/main/java/org/sonar/python/caching/PythonReadCacheImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/caching/PythonReadCacheImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/caching/PythonWriteCacheImpl.java b/python-frontend/src/main/java/org/sonar/python/caching/PythonWriteCacheImpl.java
index 227644a3fc..5db63e6837 100644
--- a/python-frontend/src/main/java/org/sonar/python/caching/PythonWriteCacheImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/caching/PythonWriteCacheImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -33,7 +33,7 @@ public synchronized void write(String key, byte[] data) {
   }
 
   @Override
-  public void copyFromPrevious(String key) {
+  public synchronized void copyFromPrevious(String key) {
     this.writeCache.copyFromPrevious(key);
   }
 }
diff --git a/python-frontend/src/main/java/org/sonar/python/caching/StringTable.java b/python-frontend/src/main/java/org/sonar/python/caching/StringTable.java
index 6167ed4a1c..f2738cc04a 100644
--- a/python-frontend/src/main/java/org/sonar/python/caching/StringTable.java
+++ b/python-frontend/src/main/java/org/sonar/python/caching/StringTable.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/caching/VarLengthInputStream.java b/python-frontend/src/main/java/org/sonar/python/caching/VarLengthInputStream.java
index 34ca977013..890c99ff02 100644
--- a/python-frontend/src/main/java/org/sonar/python/caching/VarLengthInputStream.java
+++ b/python-frontend/src/main/java/org/sonar/python/caching/VarLengthInputStream.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/caching/VarLengthOutputStream.java b/python-frontend/src/main/java/org/sonar/python/caching/VarLengthOutputStream.java
index 6034700250..555dda6af6 100644
--- a/python-frontend/src/main/java/org/sonar/python/caching/VarLengthOutputStream.java
+++ b/python-frontend/src/main/java/org/sonar/python/caching/VarLengthOutputStream.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/caching/package-info.java b/python-frontend/src/main/java/org/sonar/python/caching/package-info.java
index 13ebab1102..e8b6dde3dc 100644
--- a/python-frontend/src/main/java/org/sonar/python/caching/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/caching/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/CfgUtils.java b/python-frontend/src/main/java/org/sonar/python/cfg/CfgUtils.java
index ce704de42b..5aca537c5d 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/CfgUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/CfgUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -29,7 +29,12 @@ private CfgUtils() {
     // empty constructor
   }
 
-  public static Set unreachableBlocks(ControlFlowGraph cfg) {
+  /**
+   * Returns the blocks reachable from the control-flow graph start.
+   * @param cfg the control-flow graph to traverse
+   * @return the reachable blocks
+   */
+  public static Set reachableBlocks(ControlFlowGraph cfg) {
     Set reachableBlocks = new HashSet<>();
     Deque workList = new ArrayDeque<>();
     workList.push(cfg.start());
@@ -39,7 +44,16 @@ public static Set unreachableBlocks(ControlFlowGraph cfg) {
         currentBlock.successors().forEach(workList::push);
       }
     }
-    return difference(cfg.blocks(), reachableBlocks);
+    return reachableBlocks;
+  }
+
+  /**
+   * Returns the blocks that are not reachable from the control-flow graph start.
+   * @param cfg the control-flow graph to inspect
+   * @return the unreachable blocks
+   */
+  public static Set unreachableBlocks(ControlFlowGraph cfg) {
+    return difference(cfg.blocks(), reachableBlocks(cfg));
   }
 
   private static Set difference(Set a, Set b) {
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/ControlFlowGraphBuilder.java b/python-frontend/src/main/java/org/sonar/python/cfg/ControlFlowGraphBuilder.java
index 93d314e90d..87e8f5ce00 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/ControlFlowGraphBuilder.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/ControlFlowGraphBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -42,6 +42,7 @@
 import org.sonar.plugins.python.api.tree.IfStatement;
 import org.sonar.plugins.python.api.tree.MatchStatement;
 import org.sonar.plugins.python.api.tree.ParameterList;
+import org.sonar.plugins.python.api.tree.GroupPattern;
 import org.sonar.plugins.python.api.tree.Pattern;
 import org.sonar.plugins.python.api.tree.RaiseStatement;
 import org.sonar.plugins.python.api.tree.ReturnStatement;
@@ -192,38 +193,78 @@ private PythonCfgBlock build(Statement statement, PythonCfgBlock currentBlock) {
   private PythonCfgBlock buildClassDefStatement(ClassDef classDef, PythonCfgBlock currentBlock) {
     PythonCfgBlock block = build(classDef.body().statements(), currentBlock);
     block.addElement(classDef);
-    classDef.decorators().stream().forEach(currentBlock::addElement);
+    classDef.decorators().forEach(currentBlock::addElement);
     return block;
   }
 
   private static PythonCfgBlock buildFuncDefStatement(FunctionDef functionDef, PythonCfgBlock currentBlock) {
     currentBlock.addElement(functionDef);
-    functionDef.decorators().stream().forEach(currentBlock::addElement);
+    functionDef.decorators().forEach(currentBlock::addElement);
     return currentBlock;
   }
 
   private PythonCfgBlock buildMatchStatement(MatchStatement statement, PythonCfgBlock successor) {
     List caseBlocks = statement.caseBlocks();
-    PythonCfgBlock matchingBlock = null;
-    PythonCfgBlock falseSuccessor = successor;
+    int irrefutableIdx = findIrrefutableCaseIndex(caseBlocks);
+
+    PythonCfgBlock irrefutableBlock = null;
+    if (irrefutableIdx >= 0) {
+      CaseBlock irrefutableCase = caseBlocks.get(irrefutableIdx);
+      PythonCfgBlock irrefutableBodyBlock = build(irrefutableCase.body().statements(), createSimpleBlock(successor));
+      irrefutableBlock = createSimpleBlock(irrefutableBodyBlock);
+      irrefutableBlock.addElement(irrefutableCase.pattern());
+      irrefutableBlock.addElement(statement.subjectExpression());
+    }
+
+    PythonCfgBlock matchingBlock = irrefutableBlock;
+    PythonCfgBlock falseSuccessor = irrefutableBlock != null ? irrefutableBlock : successor;
     for (int i = caseBlocks.size() - 1; i >= 0; i--) {
-      PythonCfgBlock caseBodyBlock = createSimpleBlock(successor);
+      if (irrefutableIdx >= 0 && i >= irrefutableIdx) {
+        continue;
+      }
+      if (i == irrefutableIdx - 1) {
+        falseSuccessor = irrefutableBlock;
+      }
       CaseBlock caseBlock = caseBlocks.get(i);
       Pattern pattern = caseBlock.pattern();
       Guard guard = caseBlock.guard();
-      caseBodyBlock = build(caseBlock.body().statements(), caseBodyBlock);
+      PythonCfgBlock caseBodyBlock = build(caseBlock.body().statements(), createSimpleBlock(successor));
       matchingBlock = createBranchingBlock(pattern, caseBodyBlock, falseSuccessor);
       if (guard != null) {
         matchingBlock.addElement(guard.condition());
       }
       matchingBlock.addElement(pattern);
       matchingBlock.addElement(statement.subjectExpression());
-      blocks.add(matchingBlock);
-      falseSuccessor = matchingBlock;
+      if (i < irrefutableIdx || irrefutableIdx < 0) {
+        falseSuccessor = matchingBlock;
+      }
     }
     return matchingBlock;
   }
 
+  private static int findIrrefutableCaseIndex(List caseBlocks) {
+    for (int i = 0; i < caseBlocks.size(); i++) {
+      if (isIrrefutablePattern(caseBlocks.get(i))) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  private static boolean isIrrefutablePattern(CaseBlock caseBlock) {
+    return caseBlock.guard() == null && isIrrefutablePatternKind(caseBlock.pattern());
+  }
+
+  private static boolean isIrrefutablePatternKind(Pattern pattern) {
+    if (pattern.is(Tree.Kind.WILDCARD_PATTERN, Tree.Kind.CAPTURE_PATTERN)) {
+      return true;
+    }
+    if (pattern.is(Tree.Kind.GROUP_PATTERN)) {
+      return isIrrefutablePatternKind(((GroupPattern) pattern).pattern());
+    }
+    return false;
+  }
+
   private PythonCfgBlock buildWithStatement(WithStatement withStatement, PythonCfgBlock successor) {
     PythonCfgBlock withBodyBlock = build(withStatement.statements().statements(), createSimpleBlock(successor));
     // exceptions may be raised inside with block and be caught by context manager
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgBlock.java b/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgBlock.java
index d494e937b1..08e4bd8a9b 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgBlock.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgBlock.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgBranchingBlock.java b/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgBranchingBlock.java
index f3db34df64..4877c050d9 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgBranchingBlock.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgBranchingBlock.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgEndBlock.java b/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgEndBlock.java
index 826829a609..29a7aa2834 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgEndBlock.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgEndBlock.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgSimpleBlock.java b/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgSimpleBlock.java
index e99ef74df5..34b931a819 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgSimpleBlock.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/PythonCfgSimpleBlock.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/CfgBlockState.java b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/CfgBlockState.java
index c4ecbb084a..70f22347a5 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/CfgBlockState.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/CfgBlockState.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/DefinedVariablesAnalysis.java b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/DefinedVariablesAnalysis.java
index ea5aa645f4..56708a072f 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/DefinedVariablesAnalysis.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/DefinedVariablesAnalysis.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ForwardAnalysis.java b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ForwardAnalysis.java
index 77421ff6bf..d36351f20f 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ForwardAnalysis.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ForwardAnalysis.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/LiveVariablesAnalysis.java b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/LiveVariablesAnalysis.java
index 5ffa043926..8f5e0bbe2d 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/LiveVariablesAnalysis.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/LiveVariablesAnalysis.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ProgramState.java b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ProgramState.java
index 8273bfd641..6870454ab0 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ProgramState.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ProgramState.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ReachingDefinitionsAnalysis.java b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ReachingDefinitionsAnalysis.java
index da22d50b00..8841f4e3de 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ReachingDefinitionsAnalysis.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ReachingDefinitionsAnalysis.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -37,12 +37,14 @@
 import org.sonar.plugins.python.api.tree.AssignmentStatement;
 import org.sonar.plugins.python.api.tree.BaseTreeVisitor;
 import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.FileInput;
 import org.sonar.plugins.python.api.tree.FunctionDef;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.python.tree.TreeUtils;
 
 import static org.sonar.plugins.python.api.tree.Tree.Kind.ASSIGNMENT_STMT;
+import static org.sonar.plugins.python.api.tree.Tree.Kind.CLASSDEF;
 import static org.sonar.plugins.python.api.tree.Tree.Kind.FUNCDEF;
 import static org.sonar.plugins.python.api.tree.Tree.Kind.TRY_STMT;
 
@@ -74,17 +76,38 @@ public Set valuesAtLocation(Name variable) {
       return assignedExpressions;
     }
     FunctionDef enclosingFunction = (FunctionDef) TreeUtils.firstAncestorOfKind(variable, FUNCDEF);
-    if (enclosingFunction == null || TreeUtils.hasDescendant(enclosingFunction, t -> t.is(TRY_STMT))) {
+    if (enclosingFunction != null) {
+      return valuesInFunctionScope(variable, enclosingFunction);
+    }
+
+    FileInput fileInput = TreeUtils.firstAncestorOfClass(variable, FileInput.class);
+    if (fileInput == null) {
+      return Collections.emptySet();
+    }
+    return analyzeScope(variable, fileInput, () -> ControlFlowGraph.build(fileInput, pythonFile), fileInput.globalVariables());
+  }
+
+  private Set valuesInFunctionScope(Name variable, FunctionDef enclosingFunction) {
+    return analyzeScope(variable, enclosingFunction, () -> ControlFlowGraph.build(enclosingFunction, pythonFile), enclosingFunction.localVariables());
+  }
+
+  private Set analyzeScope(Name variable, Tree scopeTree, Supplier cfgSupplier, Set variables) {
+    if (hasTryStatementInScope(scopeTree)) {
       return Collections.emptySet();
     }
-    ControlFlowGraph cfg = ControlFlowGraph.build(enclosingFunction, pythonFile);
+    ControlFlowGraph cfg = cfgSupplier.get();
     if (cfg == null) {
       return Collections.emptySet();
     }
-    compute(cfg, enclosingFunction.localVariables());
+    compute(cfg, variables);
     return assignedExpressionByName.getOrDefault(variable, Collections.emptySet());
   }
 
+  private static boolean hasTryStatementInScope(Tree tree) {
+    return tree.children().stream().anyMatch(child ->
+      child.is(TRY_STMT) || (!child.is(FUNCDEF, CLASSDEF) && hasTryStatementInScope(child)));
+  }
+
   private Set getAssignedExpressions(Name variable, ProgramStateAtElement programStateAtElement) {
     Symbol symbol = variable.symbol();
     if (symbol == null) {
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ReadWriteVisitor.java b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ReadWriteVisitor.java
index fb1cafc95c..47135b0edc 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ReadWriteVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/ReadWriteVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/package-info.java b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/package-info.java
index e3ee6cbf5c..37605d20de 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/fixpoint/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/cfg/package-info.java b/python-frontend/src/main/java/org/sonar/python/cfg/package-info.java
index 846c63e8cc..8b5f7e41b0 100644
--- a/python-frontend/src/main/java/org/sonar/python/cfg/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/cfg/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/AliasDescriptor.java b/python-frontend/src/main/java/org/sonar/python/index/AliasDescriptor.java
index 4d0c2d0d09..809a3cafb7 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/AliasDescriptor.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/AliasDescriptor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/AmbiguousDescriptor.java b/python-frontend/src/main/java/org/sonar/python/index/AmbiguousDescriptor.java
index a0fc933d9f..e605530457 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/AmbiguousDescriptor.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/AmbiguousDescriptor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/ClassDescriptor.java b/python-frontend/src/main/java/org/sonar/python/index/ClassDescriptor.java
index 7e761801fd..ba9d467a82 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/ClassDescriptor.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/ClassDescriptor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/Descriptor.java b/python-frontend/src/main/java/org/sonar/python/index/Descriptor.java
index 13b00a80f2..dd47926aaa 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/Descriptor.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/Descriptor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/DescriptorUtils.java b/python-frontend/src/main/java/org/sonar/python/index/DescriptorUtils.java
index 970fcca532..c852d96099 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/DescriptorUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/DescriptorUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/DescriptorsToProtobuf.java b/python-frontend/src/main/java/org/sonar/python/index/DescriptorsToProtobuf.java
index c63a505c2a..81781e8857 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/DescriptorsToProtobuf.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/DescriptorsToProtobuf.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/FunctionDescriptor.java b/python-frontend/src/main/java/org/sonar/python/index/FunctionDescriptor.java
index e55692d69d..f2b85f9498 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/FunctionDescriptor.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/FunctionDescriptor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/ModuleDescriptor.java b/python-frontend/src/main/java/org/sonar/python/index/ModuleDescriptor.java
index b6db932065..a8e4a669dd 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/ModuleDescriptor.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/ModuleDescriptor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/TypeAnnotationDescriptor.java b/python-frontend/src/main/java/org/sonar/python/index/TypeAnnotationDescriptor.java
index 4249cb5ae0..d08f64f32b 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/TypeAnnotationDescriptor.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/TypeAnnotationDescriptor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/VariableDescriptor.java b/python-frontend/src/main/java/org/sonar/python/index/VariableDescriptor.java
index 9784bc0797..ae385f7e25 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/VariableDescriptor.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/VariableDescriptor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/index/package-info.java b/python-frontend/src/main/java/org/sonar/python/index/package-info.java
index 2d1cd0ecc6..f3c818c437 100644
--- a/python-frontend/src/main/java/org/sonar/python/index/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/index/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/lexer/FStringAndTStringChannel.java b/python-frontend/src/main/java/org/sonar/python/lexer/FStringAndTStringChannel.java
index 5c7e468552..c2a0557763 100644
--- a/python-frontend/src/main/java/org/sonar/python/lexer/FStringAndTStringChannel.java
+++ b/python-frontend/src/main/java/org/sonar/python/lexer/FStringAndTStringChannel.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/lexer/FStringState.java b/python-frontend/src/main/java/org/sonar/python/lexer/FStringState.java
index 5f9faed3e5..5b03d6ef8f 100644
--- a/python-frontend/src/main/java/org/sonar/python/lexer/FStringState.java
+++ b/python-frontend/src/main/java/org/sonar/python/lexer/FStringState.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/lexer/IPynbCellDelimiterChannel.java b/python-frontend/src/main/java/org/sonar/python/lexer/IPynbCellDelimiterChannel.java
index dd2cdc26ba..3889817cec 100644
--- a/python-frontend/src/main/java/org/sonar/python/lexer/IPynbCellDelimiterChannel.java
+++ b/python-frontend/src/main/java/org/sonar/python/lexer/IPynbCellDelimiterChannel.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/lexer/IndentationChannel.java b/python-frontend/src/main/java/org/sonar/python/lexer/IndentationChannel.java
index 2417c06008..5af7ff52f9 100644
--- a/python-frontend/src/main/java/org/sonar/python/lexer/IndentationChannel.java
+++ b/python-frontend/src/main/java/org/sonar/python/lexer/IndentationChannel.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/lexer/LexerState.java b/python-frontend/src/main/java/org/sonar/python/lexer/LexerState.java
index b66a52ad8f..4b4bd8d3c0 100644
--- a/python-frontend/src/main/java/org/sonar/python/lexer/LexerState.java
+++ b/python-frontend/src/main/java/org/sonar/python/lexer/LexerState.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/lexer/NewLineChannel.java b/python-frontend/src/main/java/org/sonar/python/lexer/NewLineChannel.java
index 3757bdeee0..c8401bf60c 100644
--- a/python-frontend/src/main/java/org/sonar/python/lexer/NewLineChannel.java
+++ b/python-frontend/src/main/java/org/sonar/python/lexer/NewLineChannel.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/lexer/PythonLexer.java b/python-frontend/src/main/java/org/sonar/python/lexer/PythonLexer.java
index eb03176345..6ee92c2969 100644
--- a/python-frontend/src/main/java/org/sonar/python/lexer/PythonLexer.java
+++ b/python-frontend/src/main/java/org/sonar/python/lexer/PythonLexer.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/lexer/StringLiteralsChannel.java b/python-frontend/src/main/java/org/sonar/python/lexer/StringLiteralsChannel.java
index 7e81dea0b6..ea4ba78b49 100644
--- a/python-frontend/src/main/java/org/sonar/python/lexer/StringLiteralsChannel.java
+++ b/python-frontend/src/main/java/org/sonar/python/lexer/StringLiteralsChannel.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/lexer/package-info.java b/python-frontend/src/main/java/org/sonar/python/lexer/package-info.java
index be010b2117..1f7b8f18f8 100644
--- a/python-frontend/src/main/java/org/sonar/python/lexer/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/lexer/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/metrics/CognitiveComplexityVisitor.java b/python-frontend/src/main/java/org/sonar/python/metrics/CognitiveComplexityVisitor.java
index 6141f5c581..33778aee93 100644
--- a/python-frontend/src/main/java/org/sonar/python/metrics/CognitiveComplexityVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/metrics/CognitiveComplexityVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/metrics/ComplexityVisitor.java b/python-frontend/src/main/java/org/sonar/python/metrics/ComplexityVisitor.java
index 3158852e08..2d4ace914f 100644
--- a/python-frontend/src/main/java/org/sonar/python/metrics/ComplexityVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/metrics/ComplexityVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/metrics/FileLinesVisitor.java b/python-frontend/src/main/java/org/sonar/python/metrics/FileLinesVisitor.java
index 48a287e883..9e1672a949 100644
--- a/python-frontend/src/main/java/org/sonar/python/metrics/FileLinesVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/metrics/FileLinesVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/metrics/FileMetrics.java b/python-frontend/src/main/java/org/sonar/python/metrics/FileMetrics.java
index f41d18f33f..06a8109897 100644
--- a/python-frontend/src/main/java/org/sonar/python/metrics/FileMetrics.java
+++ b/python-frontend/src/main/java/org/sonar/python/metrics/FileMetrics.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/metrics/package-info.java b/python-frontend/src/main/java/org/sonar/python/metrics/package-info.java
index 0bade320ba..e458533ef2 100644
--- a/python-frontend/src/main/java/org/sonar/python/metrics/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/metrics/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/package-info.java b/python-frontend/src/main/java/org/sonar/python/package-info.java
index dfd27de734..fbad990d67 100644
--- a/python-frontend/src/main/java/org/sonar/python/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/parser/PythonParser.java b/python-frontend/src/main/java/org/sonar/python/parser/PythonParser.java
index 31d38d1361..7642f3dd14 100644
--- a/python-frontend/src/main/java/org/sonar/python/parser/PythonParser.java
+++ b/python-frontend/src/main/java/org/sonar/python/parser/PythonParser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/parser/package-info.java b/python-frontend/src/main/java/org/sonar/python/parser/package-info.java
index 0ffc99166f..e5e44da6f5 100644
--- a/python-frontend/src/main/java/org/sonar/python/parser/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/parser/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/project/config/ProjectConfigurationBuilder.java b/python-frontend/src/main/java/org/sonar/python/project/config/ProjectConfigurationBuilder.java
index 5d784086e6..c7550ba36d 100644
--- a/python-frontend/src/main/java/org/sonar/python/project/config/ProjectConfigurationBuilder.java
+++ b/python-frontend/src/main/java/org/sonar/python/project/config/ProjectConfigurationBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.project.config;
 
 import java.util.Collection;
-import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -38,7 +37,7 @@ public ProjectConfigurationBuilder() {
   }
 
   public ProjectConfigurationBuilder addAwsLambdaHandler(String packageName, String fullyQualifiedName) {
-    awsLambdaHandlersByPackage.computeIfAbsent(packageName, k -> new HashSet<>()).add(fullyQualifiedName);
+    awsLambdaHandlersByPackage.computeIfAbsent(packageName, k -> ConcurrentHashMap.newKeySet()).add(fullyQualifiedName);
     return this;
   }
 
@@ -47,6 +46,10 @@ public ProjectConfigurationBuilder removePackageAwsLambdaHandlers(String package
     return this;
   }
 
+  public void clear() {
+    awsLambdaHandlersByPackage.clear();
+  }
+
   public ProjectConfiguration build() {
     return new ProjectConfiguration(
       new AwsProjectConfiguration(
diff --git a/python-frontend/src/main/java/org/sonar/python/project/config/SignatureBasedAwsLambdaHandlersCollector.java b/python-frontend/src/main/java/org/sonar/python/project/config/SignatureBasedAwsLambdaHandlersCollector.java
index 04bf07b91b..39251aa285 100644
--- a/python-frontend/src/main/java/org/sonar/python/project/config/SignatureBasedAwsLambdaHandlersCollector.java
+++ b/python-frontend/src/main/java/org/sonar/python/project/config/SignatureBasedAwsLambdaHandlersCollector.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/project/config/package-info.java b/python-frontend/src/main/java/org/sonar/python/project/config/package-info.java
index 73aba48a5f..47ecce2ea6 100644
--- a/python-frontend/src/main/java/org/sonar/python/project/config/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/project/config/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/quickfix/TextEditUtils.java b/python-frontend/src/main/java/org/sonar/python/quickfix/TextEditUtils.java
index 788d521835..49988068f0 100644
--- a/python-frontend/src/main/java/org/sonar/python/quickfix/TextEditUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/quickfix/TextEditUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/quickfix/package-info.java b/python-frontend/src/main/java/org/sonar/python/quickfix/package-info.java
index 7df36a769b..feb9323feb 100644
--- a/python-frontend/src/main/java/org/sonar/python/quickfix/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/quickfix/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/regex/PythonAnalyzerRegexSource.java b/python-frontend/src/main/java/org/sonar/python/regex/PythonAnalyzerRegexSource.java
index cd84c20a0e..714e6e7980 100644
--- a/python-frontend/src/main/java/org/sonar/python/regex/PythonAnalyzerRegexSource.java
+++ b/python-frontend/src/main/java/org/sonar/python/regex/PythonAnalyzerRegexSource.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/regex/PythonRegexIssueLocation.java b/python-frontend/src/main/java/org/sonar/python/regex/PythonRegexIssueLocation.java
index 41ea190fc7..7cf4aa4eb9 100644
--- a/python-frontend/src/main/java/org/sonar/python/regex/PythonRegexIssueLocation.java
+++ b/python-frontend/src/main/java/org/sonar/python/regex/PythonRegexIssueLocation.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/regex/PythonStringCharacterParser.java b/python-frontend/src/main/java/org/sonar/python/regex/PythonStringCharacterParser.java
index c519bad5bd..907d31a6a3 100644
--- a/python-frontend/src/main/java/org/sonar/python/regex/PythonStringCharacterParser.java
+++ b/python-frontend/src/main/java/org/sonar/python/regex/PythonStringCharacterParser.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/regex/RegexContext.java b/python-frontend/src/main/java/org/sonar/python/regex/RegexContext.java
index 32df357df2..aacd0836cb 100644
--- a/python-frontend/src/main/java/org/sonar/python/regex/RegexContext.java
+++ b/python-frontend/src/main/java/org/sonar/python/regex/RegexContext.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/regex/package-info.java b/python-frontend/src/main/java/org/sonar/python/regex/package-info.java
index ad9113e41d..0b2d1acdb6 100644
--- a/python-frontend/src/main/java/org/sonar/python/regex/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/regex/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/AmbiguousSymbolImpl.java b/python-frontend/src/main/java/org/sonar/python/semantic/AmbiguousSymbolImpl.java
index 622755bfa4..2d31f5228e 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/AmbiguousSymbolImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/AmbiguousSymbolImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/BuiltinSymbols.java b/python-frontend/src/main/java/org/sonar/python/semantic/BuiltinSymbols.java
index ffedabf63a..66cf2e194c 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/BuiltinSymbols.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/BuiltinSymbols.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/ClassSymbolImpl.java b/python-frontend/src/main/java/org/sonar/python/semantic/ClassSymbolImpl.java
index e8eb61c52b..153a98acc7 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/ClassSymbolImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/ClassSymbolImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/DependencyGraph.java b/python-frontend/src/main/java/org/sonar/python/semantic/DependencyGraph.java
index e97e5095d9..b55d31130d 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/DependencyGraph.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/DependencyGraph.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/FunctionSymbolImpl.java b/python-frontend/src/main/java/org/sonar/python/semantic/FunctionSymbolImpl.java
index 2b0b0426fe..3264f4851e 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/FunctionSymbolImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/FunctionSymbolImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -24,6 +24,7 @@
 import java.util.Optional;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
+import org.sonar.plugins.python.api.DjangoViewInfo;
 import org.sonar.plugins.python.api.LocationInFile;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.symbols.FunctionSymbol;
@@ -64,7 +65,8 @@ public class FunctionSymbolImpl extends SymbolImpl implements FunctionSymbol {
   private Symbol owner;
   private static final String CLASS_METHOD_DECORATOR = "classmethod";
   private static final String STATIC_METHOD_DECORATOR = "staticmethod";
-  private boolean isDjangoView = false;
+  @Nullable
+  private DjangoViewInfo djangoViewInfo = null;
   private boolean hasReadDeclaredReturnType = false;
 
   FunctionSymbolImpl(FunctionDef functionDef, @Nullable String fullyQualifiedName, PythonFile pythonFile) {
@@ -121,7 +123,6 @@ public FunctionSymbolImpl(SymbolsProtos.FunctionSymbol functionSymbolProto, @Nul
     functionDefinitionLocation = null;
     declaredReturnType = anyType();
     isStub = true;
-    isDjangoView = false;
     this.validForPythonVersions = new HashSet<>(validFor);
   }
 
@@ -168,7 +169,7 @@ public void addParameter(ParameterImpl parameter) {
       declaredReturnType = functionSymbolImpl.declaredReturnType();
     }
     isStub = functionSymbol.isStub();
-    isDjangoView = functionSymbolImpl.isDjangoView();
+    djangoViewInfo = functionSymbolImpl.djangoViewInfo;
     validForPythonVersions = functionSymbolImpl.validForPythonVersions;
 
   }
@@ -361,11 +362,11 @@ public void setOwner(Symbol owner) {
   }
 
   public boolean isDjangoView() {
-    return isDjangoView;
+    return djangoViewInfo != null;
   }
 
-  public void setIsDjangoView(boolean isDjangoView) {
-    this.isDjangoView = isDjangoView;
+  public void setDjangoViewInfo(@Nullable DjangoViewInfo djangoViewInfo) {
+    this.djangoViewInfo = djangoViewInfo;
   }
 
   public static class ParameterImpl implements Parameter {
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/ProjectLevelSymbolTable.java b/python-frontend/src/main/java/org/sonar/python/semantic/ProjectLevelSymbolTable.java
index ef11777abb..6962d06804 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/ProjectLevelSymbolTable.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/ProjectLevelSymbolTable.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,12 +22,14 @@
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
+import org.sonar.plugins.python.api.DjangoViewInfo;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.symbols.Symbol;
@@ -36,6 +38,8 @@
 import org.sonar.plugins.python.api.tree.CallExpression;
 import org.sonar.plugins.python.api.tree.FileInput;
 import org.sonar.plugins.python.api.tree.RegularArgument;
+import org.sonar.plugins.python.api.tree.StringLiteral;
+import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.types.v2.FunctionType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.plugins.python.api.types.v2.UnknownType;
@@ -58,7 +62,7 @@ public class ProjectLevelSymbolTable {
   private final PythonTypeToDescriptorConverter pythonTypeToDescriptorConverter;
   private final Map> globalDescriptorsByModuleName;
   private Map globalDescriptorsByFQN;
-  private final Set djangoViewsFQN;
+  private final Map djangoViews;
   private final Map> importsByModule;
   private final Set projectBasePackages;
   private TypeShedDescriptorsProvider typeShedDescriptorsProvider = null;
@@ -82,11 +86,24 @@ public static ProjectLevelSymbolTable from(Map> globalDe
   private ProjectLevelSymbolTable() {
     this.pythonTypeToDescriptorConverter = new PythonTypeToDescriptorConverter();
     this.globalDescriptorsByModuleName = new ConcurrentHashMap<>();
-    this.djangoViewsFQN = new HashSet<>();
+    this.djangoViews = new ConcurrentHashMap<>();
     this.importsByModule = new ConcurrentHashMap<>();
     this.projectBasePackages = new HashSet<>();
   }
 
+  /**
+   * Clears all project-derived state while keeping this table instance stable for its consumers.
+   */
+  public synchronized void clear() {
+    globalDescriptorsByModuleName.clear();
+    globalDescriptorsByFQN = null;
+    djangoViews.clear();
+    importsByModule.clear();
+    projectBasePackages.clear();
+    typeShedDescriptorsProvider = null;
+    cachedSymbols = null;
+  }
+
   public void removeModule(String packageName, String fileName) {
     String fullyQualifiedModuleName = SymbolUtils.fullyQualifiedModuleName(packageName, fileName);
     globalDescriptorsByModuleName.remove(fullyQualifiedModuleName);
@@ -115,7 +132,7 @@ public void addModule(FileInput fileInput, String packageName, PythonFile python
     globalDescriptorsByModuleName.merge(fullyQualifiedModuleName, moduleDescriptors, ProjectLevelSymbolTable::mergeDescriptors);
     addModuleToGlobalSymbolsByFQN(moduleDescriptors);
 
-    DjangoViewsVisitor djangoViewsVisitor = new DjangoViewsVisitor(fullyQualifiedModuleName);
+    DjangoViewsVisitor djangoViewsVisitor = new DjangoViewsVisitor();
     fileInput.accept(djangoViewsVisitor);
   }
 
@@ -215,12 +232,15 @@ public Set descriptorsForModule(String moduleName) {
     return globalDescriptorsByModuleName.get(moduleName);
   }
 
-  private synchronized void addDjangoView(String fqn) {
-    djangoViewsFQN.add(fqn);
+  public boolean isDjangoView(@Nullable String fqn) {
+    return fqn != null && djangoViews.containsKey(fqn);
   }
 
-  public boolean isDjangoView(@Nullable String fqn) {
-    return djangoViewsFQN.contains(fqn);
+  public Optional getDjangoViewInfo(@Nullable String fqn) {
+    if (fqn == null) {
+      return Optional.empty();
+    }
+    return Optional.ofNullable(djangoViews.get(fqn));
   }
 
   public synchronized void addProjectPackage(String projectPackage) {
@@ -274,43 +294,82 @@ public Collection stubFilesSymbols() {
 
   private class DjangoViewsVisitor extends BaseTreeVisitor {
 
-    String fullyQualifiedModuleName;
     private TypeCheckBuilder confPathCall = null;
     private TypeCheckBuilder pathCall = null;
-
-    public DjangoViewsVisitor(String fullyQualifiedModuleName) {
-      this.fullyQualifiedModuleName = fullyQualifiedModuleName;
-    }
+    private TypeCheckBuilder confRePathCall = null;
+    private TypeCheckBuilder rePathCall = null;
 
     @Override
     public void visitFileInput(FileInput fileInput) {
       TypeChecker typeChecker = new TypeChecker(new BasicTypeTable(new ProjectLevelTypeTable(ProjectLevelSymbolTable.this)));
       confPathCall = typeChecker.typeCheckBuilder().isTypeWithName("django.urls.conf.path");
       pathCall = typeChecker.typeCheckBuilder().isTypeWithName("django.urls.path");
+      confRePathCall = typeChecker.typeCheckBuilder().isTypeWithName("django.urls.conf.re_path");
+      rePathCall = typeChecker.typeCheckBuilder().isTypeWithName("django.urls.re_path");
       super.visitFileInput(fileInput);
     }
 
     @Override
     public void visitCallExpression(CallExpression callExpression) {
       super.visitCallExpression(callExpression);
-      if (isCallRegisteringDjangoView(callExpression)) {
-        RegularArgument viewArgument = nthArgumentOrKeyword(1, "view", callExpression.arguments());
-        if (viewArgument != null) {
-          PythonType pythonType = viewArgument.expression().typeV2();
-          if (pythonType instanceof UnknownType.UnresolvedImportType unresolvedImportType) {
-            String importPath = unresolvedImportType.importPath();
-            addDjangoView(importPath);
-          } else if (pythonType instanceof FunctionType functionType) {
-            addDjangoView(functionType.fullyQualifiedName());
-          }
-        }
+      if (!isCallRegisteringDjangoView(callExpression)) {
+        return;
       }
+
+      extractViewFqnFromArgument(callExpression)
+        .ifPresent(fqn -> registerDjangoView(fqn, extractUrlPattern(callExpression)));
+    }
+
+    private Optional extractViewFqnFromArgument(CallExpression callExpression) {
+      return extractArgument(callExpression, 1, "view")
+        .map(arg -> arg.expression().typeV2())
+        .flatMap(this::extractFullyQualifiedName);
+    }
+
+    private Optional extractArgument(CallExpression callExpression, int position, String name) {
+      return Optional.ofNullable(nthArgumentOrKeyword(position, name, callExpression.arguments()));
+    }
+
+    private Optional extractFullyQualifiedName(PythonType pythonType) {
+      if (pythonType instanceof UnknownType.UnresolvedImportType unresolvedImportType) {
+        return Optional.of(unresolvedImportType.importPath());
+      } else if (pythonType instanceof FunctionType functionType) {
+        return Optional.ofNullable(functionType.fullyQualifiedName());
+      }
+      return Optional.empty();
+    }
+
+    private void registerDjangoView(String fqn, @Nullable String urlPattern) {
+      addDjangoView(fqn);
+      if (urlPattern != null) {
+        addDjangoViewUrlPattern(fqn, urlPattern);
+      }
+    }
+
+    @CheckForNull
+    private String extractUrlPattern(CallExpression callExpression) {
+      return extractArgument(callExpression, 0, "route")
+        .filter(arg -> arg.expression().is(Tree.Kind.STRING_LITERAL))
+        .map(arg -> ((StringLiteral) arg.expression()).trimmedQuotesValue())
+        .orElse(null);
     }
 
     private boolean isCallRegisteringDjangoView(CallExpression callExpression) {
       TriBool isConfPathCall = confPathCall.check(callExpression.callee().typeV2());
       TriBool isPathCall = pathCall.check(callExpression.callee().typeV2());
-      return isConfPathCall.equals(TriBool.TRUE) || isPathCall.equals(TriBool.TRUE);
+      TriBool isConfRePathCall = confRePathCall.check(callExpression.callee().typeV2());
+      TriBool isRePathCall = rePathCall.check(callExpression.callee().typeV2());
+      return isConfPathCall.equals(TriBool.TRUE) || isPathCall.equals(TriBool.TRUE)
+        || isConfRePathCall.equals(TriBool.TRUE) || isRePathCall.equals(TriBool.TRUE);
+    }
+
+    private void addDjangoView(String fqn) {
+      djangoViews.computeIfAbsent(fqn, k -> DjangoViewInfo.withoutPatterns());
+    }
+
+    private void addDjangoViewUrlPattern(String fqn, String urlPattern) {
+      djangoViews.compute(fqn, (k, existing) ->
+        existing == null ? DjangoViewInfo.withPattern(urlPattern) : existing.addPattern(urlPattern));
     }
   }
 }
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/Scope.java b/python-frontend/src/main/java/org/sonar/python/semantic/Scope.java
index 7f03dcbdb8..cd3f1b065c 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/Scope.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/Scope.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -114,7 +114,8 @@ void addFunctionSymbol(FunctionDef functionDef, @Nullable String fullyQualifiedN
       addBindingUsage(functionDef.name(), Usage.Kind.FUNC_DECLARATION, fullyQualifiedName);
     } else {
       FunctionSymbolImpl functionSymbol = new FunctionSymbolImpl(functionDef, fullyQualifiedName, pythonFile);
-      functionSymbol.setIsDjangoView(projectLevelSymbolTable.isDjangoView(fullyQualifiedName));
+      projectLevelSymbolTable.getDjangoViewInfo(fullyQualifiedName)
+        .ifPresent(functionSymbol::setDjangoViewInfo);
       ((FunctionDefImpl) functionDef).setFunctionSymbol(functionSymbol);
       symbols.add(functionSymbol);
       symbolsByName.put(symbolName, functionSymbol);
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/SelfSymbolImpl.java b/python-frontend/src/main/java/org/sonar/python/semantic/SelfSymbolImpl.java
index 29d7de9ed6..564ddaaf0c 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/SelfSymbolImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/SelfSymbolImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/SymbolImpl.java b/python-frontend/src/main/java/org/sonar/python/semantic/SymbolImpl.java
index b1805f713f..1dfe36417f 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/SymbolImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/SymbolImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/SymbolTableBuilder.java b/python-frontend/src/main/java/org/sonar/python/semantic/SymbolTableBuilder.java
index 4679690d13..f796faa399 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/SymbolTableBuilder.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/SymbolTableBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -342,6 +342,7 @@ private void createTypeParameters(@Nullable TypeParams typeParams) {
     @Override
     public void visitTypeAliasStatement(TypeAliasStatement typeAliasStatement) {
       addBindingUsage(typeAliasStatement.name(), Usage.Kind.TYPE_ALIAS_DECLARATION);
+      createTypeParameters(typeAliasStatement.typeParams());
       super.visitTypeAliasStatement(typeAliasStatement);
     }
 
@@ -697,6 +698,7 @@ public void visitTypeAnnotation(TypeAnnotation tree) {
     public void visitClassDef(ClassDef pyClassDefTree) {
       scan(pyClassDefTree.args());
       scan(pyClassDefTree.decorators());
+      scan(pyClassDefTree.typeParams());
       enterScope(pyClassDefTree);
       scan(pyClassDefTree.name());
       resolveTypeHierarchy(pyClassDefTree, pyClassDefTree.name().symbol(), pythonFile, scopesByRootTree.get(fileInput).symbolsByName);
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/SymbolUtils.java b/python-frontend/src/main/java/org/sonar/python/semantic/SymbolUtils.java
index 9bc860cdd1..5982e1b599 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/SymbolUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/SymbolUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,14 +20,13 @@
 import static org.sonar.python.tree.TreeUtils.getSymbolFromTree;
 
 import java.io.File;
+import java.io.IOException;
 import java.net.URI;
 import java.nio.file.InvalidPathException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Deque;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -35,7 +34,9 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.sonar.plugins.python.api.PythonFile;
@@ -171,30 +172,35 @@ public static List boundNamesFromExpression(@CheckForNull Tree tree) {
   /**
    * Computes the Python package name for a file using package roots.
    *
-   * 
                  If the file is under one of the provided package roots, computes the package name
-   * by converting the relative path from the root to the file's parent directory into a
-   * dotted package name. This supports PEP 420 namespace packages (directories without __init__.py).
+   * 
                  Finds the first root whose path is a prefix of the file's path and computes the
+   * package name by converting the relative path from that root to the file's parent directory
+   * into a dotted package name. This supports PEP 420 namespace packages (no __init__.py required).
    *
-   * 
                  If the file is not under any package root, falls back to the legacy behavior of
-   * walking up the directory tree and checking for __init__.py files.
+   * 
                  Returns an empty string when the file does not fall under any of the provided roots.
    *
    * @param file the Python source file
    * @param packageRoots list of absolute paths to package root directories
-   * @param projectBaseDirAbsolutePath the project base directory absolute path (used for fallback)
-   * @return the dotted package name, or empty string if not in a package
+   * @return the dotted package name, or empty string if not under any root
    */
-  public static String pythonPackageName(File file, List packageRoots, String projectBaseDirAbsolutePath) {
-    if (!packageRoots.isEmpty()) {
-      String filePath = file.getAbsolutePath();
-      for (String root : packageRoots) {
-        String normalizedRoot = root.endsWith(File.separator) ? root : (root + File.separator);
-        if (filePath.startsWith(normalizedRoot)) {
-          return computePackageNameFromRoot(file, normalizedRoot);
-        }
+  public static String pythonPackageName(File file, List packageRoots) {
+    List resolvedPackageRoots = packageRoots.stream()
+      .map(root -> resolvedPath(new File(root)))
+      .toList();
+    return pythonPackageName(file, resolvedPackageRoots);
+  }
+
+  /**
+   * Computes the Python package name using package roots that have already been resolved across
+   * filesystem aliases. This overload avoids resolving the same roots for every file in a project.
+   */
+  public static String pythonPackageName(File file, Iterable resolvedPackageRoots) {
+    Path filePath = resolvedPath(file);
+    for (Path rootPath : resolvedPackageRoots) {
+      if (filePath.startsWith(rootPath)) {
+        return computePackageNameFromRoot(filePath, rootPath);
       }
     }
-    // Fallback to legacy __init__.py-based detection
-    return pythonPackageNameLegacy(file, projectBaseDirAbsolutePath);
+    return "";
   }
 
   /**
@@ -202,53 +208,38 @@ public static String pythonPackageName(File file, List packageRoots, Str
    * All directories between the root and the file become part of the package name
    * (PEP 420 namespace package support).
    */
-  private static String computePackageNameFromRoot(File file, String packageRoot) {
-    File parentDir = file.getParentFile();
-    if (parentDir == null) {
-      return "";
-    }
-    String parentPath = parentDir.getAbsolutePath();
-    if (!parentPath.startsWith(packageRoot)) {
+  private static String computePackageNameFromRoot(Path file, Path packageRoot) {
+    Path parentDir = file.getParent();
+    if (parentDir == null || !parentDir.startsWith(packageRoot)) {
       return "";
     }
-    String relativePath = parentPath.substring(packageRoot.length());
-    if (relativePath.isEmpty()) {
+    Path relativePath = packageRoot.relativize(parentDir);
+    if (relativePath.getNameCount() == 0) {
       return "";
     }
-    // Convert path separators to dots
-    return relativePath.replace(File.separatorChar, '.');
+    return StreamSupport.stream(relativePath.spliterator(), false)
+      .map(Path::toString)
+      .collect(Collectors.joining("."));
   }
 
   /**
-   * Legacy method for computing Python package name using __init__.py detection.
-   * Walks up from the file's parent directory toward the project base directory,
-   * stopping when encountering a directory without __init__.py.
+   * Resolves filesystem aliases, including Windows 8.3 short paths. If the complete path does
+   * not exist, the nearest existing ancestor is resolved and the remaining path is appended.
    */
-  private static String pythonPackageNameLegacy(File file, String projectBaseDirAbsolutePath) {
-    File currentDirectory = file.getParentFile();
-    Deque packages = new ArrayDeque<>();
-    while (!currentDirectory.getAbsolutePath().equals(projectBaseDirAbsolutePath)) {
-      File initFile = new File(currentDirectory, "__init__.py");
-      if (!initFile.exists()) {
-        break;
+  public static Path resolvedPath(File file) {
+    Path absolutePath = file.toPath().toAbsolutePath().normalize();
+    Path existingAncestor = absolutePath;
+    while (existingAncestor != null) {
+      try {
+        return existingAncestor.toRealPath().resolve(existingAncestor.relativize(absolutePath));
+      } catch (IOException e) {
+        existingAncestor = existingAncestor.getParent();
       }
-      packages.push(currentDirectory.getName());
-      currentDirectory = currentDirectory.getParentFile();
     }
-    return String.join(".", packages);
+    return absolutePath;
   }
 
-  /**
-   * Computes the Python package name for a file using legacy __init__.py detection only.
-   * This method is kept for backward compatibility.
-   *
-   * @param file the Python source file
-   * @param projectBaseDirAbsolutePath the project base directory absolute path
-   * @return the dotted package name, or empty string if not in a package
-   */
-  public static String pythonPackageName(File file, String projectBaseDirAbsolutePath) {
-    return pythonPackageNameLegacy(file, projectBaseDirAbsolutePath);
-  }
+
 
   @CheckForNull
   public static Path pathOf(PythonFile pythonFile) {
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/UsageImpl.java b/python-frontend/src/main/java/org/sonar/python/semantic/UsageImpl.java
index fc8b896f90..4d6782ac32 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/UsageImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/UsageImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/package-info.java b/python-frontend/src/main/java/org/sonar/python/semantic/package-info.java
index 8e395b9596..ef465772c1 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/ClassTypeBuilder.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/ClassTypeBuilder.java
index db97a440dd..5feae89430 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/ClassTypeBuilder.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/ClassTypeBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/FunctionTypeBuilder.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/FunctionTypeBuilder.java
index 7fe711c520..b830d03aa9 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/FunctionTypeBuilder.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/FunctionTypeBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/LazyTypesContext.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/LazyTypesContext.java
index 17ec56d0a1..327bcb1bde 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/LazyTypesContext.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/LazyTypesContext.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/ReadUsagesVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/ReadUsagesVisitor.java
index 05fce61d45..c921978d3d 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/ReadUsagesVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/ReadUsagesVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -121,6 +121,7 @@ public void visitTypeAnnotation(TypeAnnotation tree) {
   public void visitClassDef(ClassDef classDef) {
     scan(classDef.args());
     scan(classDef.decorators());
+    scan(classDef.typeParams());
     enterScope(classDef);
     scan(classDef.name());
     scan(classDef.body());
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeV2.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeV2.java
index 71b6eadce6..b3b3ab8643 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeV2.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeV2.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeVisitor.java
index aef2f64efc..ceb0432701 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/ScopeVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolTable.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolTable.java
index b478c758ad..6b60ddb744 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolTable.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolTable.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2.java
index 36b58cdefd..a84de48d8d 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolV2Impl.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolV2Impl.java
index 7c87305aeb..80915757a5 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolV2Impl.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolV2Impl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolV2Utils.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolV2Utils.java
index 9ca42f34ad..f1caa24472 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolV2Utils.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolV2Utils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolsModuleTypeProvider.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolsModuleTypeProvider.java
index ab22ae11a7..5c8ab84c43 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolsModuleTypeProvider.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolsModuleTypeProvider.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/TypeBuilder.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/TypeBuilder.java
index 2c237ad48f..0225c85fda 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/TypeBuilder.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/TypeBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/TypeInferenceV2.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/TypeInferenceV2.java
index 0d8b506ca6..6be9d44393 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/TypeInferenceV2.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/TypeInferenceV2.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,6 +18,7 @@
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -57,6 +58,7 @@ public class TypeInferenceV2 {
   private final SymbolTable symbolTable;
   private final PythonFile pythonFile;
   private final String fullyQualifiedModuleName;
+  private final Map cfgMap = new HashMap<>();
   private Set importedModulesFQN;
 
   public TypeInferenceV2(TypeTable projectLevelTypeTable, PythonFile pythonFile, SymbolTable symbolTable, String packageName) {
@@ -156,6 +158,11 @@ private Map> inferTypesAndMemberAccessSymbols(Tree sco
       .map(Propagation::lhsName)
       .collect(Collectors.toSet());
 
+    ControlFlowGraph cfg = controlFlowGraphSupplier.get();
+    if (cfg != null) {
+      cfgMap.put(scopeTree, cfg);
+    }
+
     TryStatementVisitor tryStatementVisitor = new TryStatementVisitor();
     statements.accept(tryStatementVisitor);
     if (tryStatementVisitor.hasTryStatement()) {
@@ -164,7 +171,6 @@ private Map> inferTypesAndMemberAccessSymbols(Tree sco
         .process(getTrackedVars(declaredVariables, assignedNames));
     }
 
-    ControlFlowGraph cfg = controlFlowGraphSupplier.get();
     if (cfg == null) {
       return Map.of();
     }
@@ -221,4 +227,8 @@ private static Set getTrackedVars(Set localVariables, Set importedModulesFQN() {
     return importedModulesFQN;
   }
+
+  public Map getCfgMap() {
+    return Collections.unmodifiableMap(cfgMap);
+  }
 }
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/UsageV2Impl.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/UsageV2Impl.java
index 27895ca72c..f853336440 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/UsageV2Impl.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/UsageV2Impl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/WriteUsagesVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/WriteUsagesVisitor.java
index 5ab37618c2..35b9d62f0a 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/WriteUsagesVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/WriteUsagesVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -171,6 +171,7 @@ private void addTupleParamElementsToBindingUsage(TupleParameter param) {
   @Override
   public void visitTypeAliasStatement(TypeAliasStatement typeAliasStatement) {
     currentScope().addBindingUsage(typeAliasStatement.name(), UsageV2.Kind.TYPE_ALIAS_DECLARATION);
+    createTypeParameters(typeAliasStatement.typeParams());
     super.visitTypeAliasStatement(typeAliasStatement);
   }
 
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraph.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraph.java
index 28b9847930..fb9731a6a8 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraph.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraph.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphCollector.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphCollector.java
index ac52207811..c74e7de123 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphCollector.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphCollector.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphIterable.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphIterable.java
index 8b4fe4dc67..7c220f77e9 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphIterable.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphIterable.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphNode.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphNode.java
index 708862ac37..11e9430017 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphNode.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphNode.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphWalker.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphWalker.java
index 438d5f4eb6..b2fd977c0d 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphWalker.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/CallGraphWalker.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/package-info.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/package-info.java
index 0153721eb5..198f74bcfb 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/callgraph/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AliasDescriptorToPythonTypeConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AliasDescriptorToPythonTypeConverter.java
index 8139ed4304..07e85552a0 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AliasDescriptorToPythonTypeConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AliasDescriptorToPythonTypeConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AmbiguousDescriptorToPythonTypeConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AmbiguousDescriptorToPythonTypeConverter.java
index 228c9a7841..d15b34fb8d 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AmbiguousDescriptorToPythonTypeConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AmbiguousDescriptorToPythonTypeConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AnyDescriptorToPythonTypeConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AnyDescriptorToPythonTypeConverter.java
index bd3662ea74..2c35158093 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AnyDescriptorToPythonTypeConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/AnyDescriptorToPythonTypeConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ClassDescriptorToPythonTypeConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ClassDescriptorToPythonTypeConverter.java
index 765ee59e04..867719ca3d 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ClassDescriptorToPythonTypeConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ClassDescriptorToPythonTypeConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ConversionContext.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ConversionContext.java
index 49ce82e475..bb124ae8c1 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ConversionContext.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ConversionContext.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/DescriptorToPythonTypeConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/DescriptorToPythonTypeConverter.java
index 822e027a85..f9ae44908e 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/DescriptorToPythonTypeConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/DescriptorToPythonTypeConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/FunctionDescriptorToPythonTypeConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/FunctionDescriptorToPythonTypeConverter.java
index 1062aa44b9..15cf8f0f16 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/FunctionDescriptorToPythonTypeConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/FunctionDescriptorToPythonTypeConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ParameterConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ParameterConverter.java
index a667691df3..f99a60b95e 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ParameterConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/ParameterConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/PythonTypeToDescriptorConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/PythonTypeToDescriptorConverter.java
index 829ca7fa64..284281ce44 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/PythonTypeToDescriptorConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/PythonTypeToDescriptorConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/TypeAnnotationToPythonTypeConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/TypeAnnotationToPythonTypeConverter.java
index d5f8a06932..141cc57604 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/TypeAnnotationToPythonTypeConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/TypeAnnotationToPythonTypeConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/UnknownDescriptorToPythonTypeConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/UnknownDescriptorToPythonTypeConverter.java
index 9904edc8b8..68d59bc8ee 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/UnknownDescriptorToPythonTypeConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/UnknownDescriptorToPythonTypeConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/VariableDescriptorToPythonTypeConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/VariableDescriptorToPythonTypeConverter.java
index 62b57fd324..207571a6fa 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/VariableDescriptorToPythonTypeConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/VariableDescriptorToPythonTypeConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/package-info.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/package-info.java
index 76fca63b2c..6a844783c3 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/converter/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/dynamicstubs/DynamicStubsProvider.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/dynamicstubs/DynamicStubsProvider.java
index 627cc84f01..5c8a233ae3 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/dynamicstubs/DynamicStubsProvider.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/dynamicstubs/DynamicStubsProvider.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/dynamicstubs/package-info.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/dynamicstubs/package-info.java
index 545f8f4386..1dc6299d34 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/dynamicstubs/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/dynamicstubs/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/package-info.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/package-info.java
index d6d1c3b641..9adf81b20a 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Assignment.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Assignment.java
index 7e4541b04b..913da6f19f 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Assignment.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Assignment.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/AstBasedTypeInference.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/AstBasedTypeInference.java
index 877deffe2d..6e8a9d94b0 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/AstBasedTypeInference.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/AstBasedTypeInference.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Definition.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Definition.java
index 0453fbec5b..f5759aa7dd 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Definition.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Definition.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/FlowSensitiveTypeInference.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/FlowSensitiveTypeInference.java
index 4b77f9ce83..87cf172a46 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/FlowSensitiveTypeInference.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/FlowSensitiveTypeInference.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/IsInstanceVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/IsInstanceVisitor.java
index 42255d4045..ab3531bfc5 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/IsInstanceVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/IsInstanceVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/LoopAssignment.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/LoopAssignment.java
index 44e452a0d1..70a38a393b 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/LoopAssignment.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/LoopAssignment.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/ParameterDefinition.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/ParameterDefinition.java
index 7ce8f4af9b..8c963e0009 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/ParameterDefinition.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/ParameterDefinition.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/ProgramStateTypeInferenceVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/ProgramStateTypeInferenceVisitor.java
index 5b2ba290f0..eb8944f334 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/ProgramStateTypeInferenceVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/ProgramStateTypeInferenceVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Propagation.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Propagation.java
index e4d15bbe5b..c3f0d48e50 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Propagation.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/Propagation.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/PropagationVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/PropagationVisitor.java
index dc7d30227e..106db7038c 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/PropagationVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/PropagationVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TrivialTypeInferenceVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TrivialTypeInferenceVisitor.java
index d557000b84..42ca9a6487 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TrivialTypeInferenceVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TrivialTypeInferenceVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -89,6 +89,7 @@
 import org.sonar.python.semantic.v2.types.typecalculator.CallReturnTypeCalculator;
 import org.sonar.python.semantic.v2.types.typecalculator.QualifiedExpressionCalculator;
 import org.sonar.python.semantic.v2.typetable.TypeTable;
+import org.sonar.python.semantic.v2.typeshed.TypeShedConstants;
 import org.sonar.python.tree.AwaitExpressionImpl;
 import org.sonar.python.tree.BinaryExpressionImpl;
 import org.sonar.python.tree.CallExpressionImpl;
@@ -132,6 +133,9 @@ public class TrivialTypeInferenceVisitor extends BaseTreeVisitor {
       TypeInferenceMatchers.withFQN("typing.Self"),
       TypeInferenceMatchers.withFQN("typing_extensions.Self")));
 
+  private static final String PYTEST_MODULE = "pytest";
+  private static final String PYTEST_REQUEST_PARAMETER = "request";
+
   private record DeferredTree(Tree tree, Scope scope) {
   }
 
@@ -192,14 +196,19 @@ public void visitFileInput(FileInput fileInput) {
 
   @Override
   public void visitStringLiteral(StringLiteral stringLiteral) {
+    super.visitStringLiteral(stringLiteral);
     var builtins = this.projectLevelTypeTable.getBuiltinsModule();
     // TODO: SONARPY-1867 multiple object types to represent str instance?
-    if (((StringLiteralImpl) stringLiteral).isTemplate()) {
+    StringLiteralImpl stringLiteralImpl = (StringLiteralImpl) stringLiteral;
+    if (stringLiteralImpl.isTemplate()) {
       // TODO: SONARPY-3427 once provided by typeshed the resolved type should be string.templatelib.Template
-      ((StringLiteralImpl) stringLiteral).typeV2(ObjectType.fromType(PythonType.UNKNOWN));
+      stringLiteralImpl.typeV2(ObjectType.fromType(PythonType.UNKNOWN));
+    } else if (stringLiteralImpl.isBytes()) {
+      PythonType bytesType = builtins.resolveMember("bytes").orElse(PythonType.UNKNOWN);
+      stringLiteralImpl.typeV2(ObjectType.fromType(bytesType));
     } else {
       PythonType strType = builtins.resolveMember("str").orElse(PythonType.UNKNOWN);
-      ((StringLiteralImpl) stringLiteral).typeV2(ObjectType.fromType(strType));
+      stringLiteralImpl.typeV2(ObjectType.fromType(strType));
     }
   }
 
@@ -398,6 +407,7 @@ public void visitFunctionDef(FunctionDef functionDef) {
       scan(functionDef.typeParams());
       scan(functionDef.parameters());
       setSelfParameterType(functionDef);
+      setPytestRequestParameterType(functionDef);
       deferTree(functionDef.body());
     });
   }
@@ -479,6 +489,32 @@ private void setSelfParameterType(FunctionDef functionDef) {
     }
   }
 
+  private void setPytestRequestParameterType(FunctionDef functionDef) {
+    if (!importedModulesFQN.contains(PYTEST_MODULE)) {
+      return;
+    }
+
+    var parameterList = functionDef.parameters();
+    if (parameterList == null) {
+      return;
+    }
+
+    PythonType fixtureRequestType = projectLevelTypeTable.getType(TypeShedConstants.PYTEST_FIXTURE_REQUEST_FQN);
+    if (fixtureRequestType instanceof UnknownType) {
+      return;
+    }
+
+    var requestObjectType = ObjectType.Builder.fromType(fixtureRequestType)
+      .withTypeSource(TypeSource.EXACT)
+      .build();
+
+    parameterList.nonTuple().stream()
+      .filter(parameter -> parameter.typeAnnotation() == null)
+      .map(Parameter::name)
+      .filter(name -> name != null && PYTEST_REQUEST_PARAMETER.equals(name.name()))
+      .forEach(name -> setTypeToName(name, requestObjectType));
+  }
+
   @Override
   public void visitImportName(ImportName importName) {
     importName.modules()
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TrivialTypePropagationVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TrivialTypePropagationVisitor.java
index 035650cba0..324966a058 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TrivialTypePropagationVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TrivialTypePropagationVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TryStatementVisitor.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TryStatementVisitor.java
index 81daf468b1..663e3510db 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TryStatementVisitor.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TryStatementVisitor.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeDependenciesCalculator.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeDependenciesCalculator.java
index 893697a49f..b196399bb7 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeDependenciesCalculator.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeDependenciesCalculator.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceMatcher.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceMatcher.java
index a69fcdb586..cceb29c64e 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceMatcher.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceMatcher.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceMatchers.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceMatchers.java
index 491492c69e..6be35ba21b 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceMatchers.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceMatchers.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceProgramState.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceProgramState.java
index 236e8952f6..2c001ad3ae 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceProgramState.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/TypeInferenceProgramState.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/package-info.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/package-info.java
index 992484b55d..89a95db626 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/AwaitedTypeCalculator.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/AwaitedTypeCalculator.java
index 7e2b13ca07..619e8394d5 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/AwaitedTypeCalculator.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/AwaitedTypeCalculator.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/CallReturnTypeCalculator.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/CallReturnTypeCalculator.java
index 236167e7e9..12e50c14d9 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/CallReturnTypeCalculator.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/CallReturnTypeCalculator.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,9 +19,11 @@
 import java.util.HashSet;
 import java.util.Optional;
 import java.util.Set;
+import javax.annotation.CheckForNull;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.CallExpression;
 import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.FunctionDef;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.QualifiedExpression;
 import org.sonar.plugins.python.api.tree.RegularArgument;
@@ -30,6 +32,7 @@
 import org.sonar.plugins.python.api.types.v2.ObjectType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.plugins.python.api.types.v2.SelfType;
+import org.sonar.plugins.python.api.types.v2.SuperProxyType;
 import org.sonar.plugins.python.api.types.v2.TypeOrigin;
 import org.sonar.plugins.python.api.types.v2.TypeSource;
 import org.sonar.plugins.python.api.types.v2.UnionType;
@@ -51,6 +54,12 @@ public static PythonType computeCallExpressionType(CallExpression callExpr, Type
       return getFirstArgumentType(callExpr);
     }
 
+    // Zero-argument super() inside a method: return a proxy type that resolves members from the parent class hierarchy.
+    PythonType superProxy = computeSuperProxyType(callExpr, typePredicateContext);
+    if (superProxy != null) {
+      return superProxy;
+    }
+
     PythonType calleeType = callExpr.callee().typeV2();
     TypeSource typeSource = computeTypeSource(calleeType, callExpr);
     PythonType returnType = returnTypeOfCall(calleeType);
@@ -64,6 +73,46 @@ public static PythonType computeCallExpressionType(CallExpression callExpr, Type
     return collapseSelfTypeIfNeeded(callExpr, returnType, typePredicateContext);
   }
 
+  /**
+   * When {@code super()} is called with zero arguments inside a method, Python returns a
+   * proxy object that delegates attribute lookup to the parent class hierarchy (skipping the
+   * current class). This method computes an {@code ObjectType} backed by a proxy type that resolves
+   * members on the enclosing class's C3 MRO tail.
+   *
+   * @return the super proxy {@code ObjectType}, or {@code null} if the call is not a zero-arg super()
+   */
+  @CheckForNull
+  private static PythonType computeSuperProxyType(CallExpression callExpr, TypePredicateContext typePredicateContext) {
+    // Only handle zero-argument super() calls
+    if (!callExpr.arguments().isEmpty()) {
+      return null;
+    }
+    // The callee must resolve to the builtin 'super' ClassType
+    var isSuper = TypeInferenceMatcher.of(TypeInferenceMatchers.isType(SuperProxyType.SUPER_FQN)).evaluate(callExpr.callee().typeV2(), typePredicateContext);
+    if (isSuper != TriBool.TRUE) {
+      return null;
+    }
+
+    ClassType ownerClassType = findEnclosingMethodOwner(callExpr);
+    if (ownerClassType == null || ownerClassType.mro().filter(mro -> mro.size() > 1).isEmpty()) {
+      return null;
+    }
+    return ObjectType.fromType(new SuperProxyType(ownerClassType));
+  }
+
+  @CheckForNull
+  private static ClassType findEnclosingMethodOwner(CallExpression callExpr) {
+    FunctionDef enclosingFunctionDef = TreeUtils.firstAncestorOfClass(callExpr, FunctionDef.class);
+    if (enclosingFunctionDef == null) {
+      return null;
+    }
+    PythonType funcType = enclosingFunctionDef.name().typeV2();
+    if (!(funcType instanceof FunctionType functionType) || (!functionType.isInstanceMethod() && !functionType.isClassMethod())) {
+      return null;
+    }
+    return functionType.owner() instanceof ClassType classType ? classType : null;
+  }
+
   private static PythonType returnTypeOfCall(PythonType calleeType) {
     if (calleeType instanceof ClassType classType) {
       return ObjectType.fromType(classType);
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/QualifiedExpressionCalculator.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/QualifiedExpressionCalculator.java
index 2c07273d52..8fa48b3a99 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/QualifiedExpressionCalculator.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/QualifiedExpressionCalculator.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,11 +17,12 @@
 package org.sonar.python.semantic.v2.types.typecalculator;
 
 import java.util.Optional;
-import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.QualifiedExpression;
+import org.sonar.plugins.python.api.types.v2.FullyQualifiedNameHelper;
 import org.sonar.plugins.python.api.types.v2.FunctionType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
+import org.sonar.plugins.python.api.types.v2.UnknownType;
 import org.sonar.python.semantic.v2.types.TypeInferenceMatcher;
 import org.sonar.python.semantic.v2.types.TypeInferenceMatchers;
 import org.sonar.python.types.v2.matchers.TypePredicateContext;
@@ -38,10 +39,16 @@ public QualifiedExpressionCalculator(TypePredicateContext typePredicateContext)
 
   public PythonType calculate(QualifiedExpression qualifiedExpression) {
     Name name = qualifiedExpression.name();
-    return Optional.of(qualifiedExpression.qualifier())
-      .map(Expression::typeV2)
+    PythonType qualifierType = qualifiedExpression.qualifier().typeV2();
+    return Optional.of(qualifierType)
       .flatMap(t -> t.resolveMember(name.name()))
       .map(this::handlePropertyFunction)
+      .orElseGet(() -> unresolvedMemberType(qualifierType, name.name()));
+  }
+
+  private static PythonType unresolvedMemberType(PythonType qualifierType, String memberName) {
+    return FullyQualifiedNameHelper.getFullyQualifiedName(qualifierType)
+      .map(qualifierFqn -> (PythonType) new UnknownType.UnresolvedImportType(qualifierFqn + "." + memberName))
       .orElse(PythonType.UNKNOWN);
   }
 
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/package-info.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/package-info.java
index ac55aa41af..2c53c85539 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/types/typecalculator/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ClassSymbolToDescriptorConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ClassSymbolToDescriptorConverter.java
index eda0e7e048..9114b043f9 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ClassSymbolToDescriptorConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ClassSymbolToDescriptorConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/FunctionSymbolToDescriptorConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/FunctionSymbolToDescriptorConverter.java
index 72c7662685..0d77738483 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/FunctionSymbolToDescriptorConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/FunctionSymbolToDescriptorConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ModuleSymbolToDescriptorConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ModuleSymbolToDescriptorConverter.java
index 3254583480..d7fc07b0a4 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ModuleSymbolToDescriptorConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ModuleSymbolToDescriptorConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/OverloadedFunctionSymbolToDescriptorConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/OverloadedFunctionSymbolToDescriptorConverter.java
index 047ca155ae..8fddbe4ddb 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/OverloadedFunctionSymbolToDescriptorConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/OverloadedFunctionSymbolToDescriptorConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ParameterSymbolToDescriptorConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ParameterSymbolToDescriptorConverter.java
index 4fc90e9f87..3946d1b62d 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ParameterSymbolToDescriptorConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ParameterSymbolToDescriptorConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ProtoUtils.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ProtoUtils.java
index 5283bbaacd..c63121a7d5 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ProtoUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/ProtoUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedConstants.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedConstants.java
index fd05e71c2c..087703ff0e 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedConstants.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedConstants.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -23,6 +23,9 @@ public class TypeShedConstants {
   public static final String BUILTINS_NONE_TYPE_FQN = BUILTINS_PREFIX + "NoneType";
   public static final String BUILTINS_TUPLE_FQN = BUILTINS_PREFIX + "tuple";
   public static final String BUILTINS_DICT_FQN = BUILTINS_PREFIX + "dict";
+  public static final String PYTEST_FIXTURE_REQUEST_FQN = "_pytest.fixtures.FixtureRequest";
+  public static final String PYTEST_FIXTURE_REQUEST_GET_FIXTURE_VALUE_FQN = PYTEST_FIXTURE_REQUEST_FQN + ".getfixturevalue";
+  public static final String PYTEST_FIXTURE_REQUEST_ADD_FINALIZER_FQN = PYTEST_FIXTURE_REQUEST_FQN + ".addfinalizer";
 
   private TypeShedConstants() {
   }
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedDescriptorsProvider.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedDescriptorsProvider.java
index a8bfd89c11..068e3c7821 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedDescriptorsProvider.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedDescriptorsProvider.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedUtils.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedUtils.java
index f567f385c2..d2635e6251 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeShedUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeSymbolToDescriptorConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeSymbolToDescriptorConverter.java
index 2dd8495be9..13902f830d 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeSymbolToDescriptorConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/TypeSymbolToDescriptorConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/VarSymbolToDescriptorConverter.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/VarSymbolToDescriptorConverter.java
index 15e6d586e5..10ef00c005 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/VarSymbolToDescriptorConverter.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/VarSymbolToDescriptorConverter.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/package-info.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/package-info.java
index d74c18422d..76991a050b 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typeshed/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/BasicTypeTable.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/BasicTypeTable.java
index fcde81489e..e146152b78 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/BasicTypeTable.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/BasicTypeTable.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/CachedTypeTable.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/CachedTypeTable.java
index 1c2e4ca3fc..1b7a4bfc89 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/CachedTypeTable.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/CachedTypeTable.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/ProjectLevelTypeTable.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/ProjectLevelTypeTable.java
index a99c0dedd5..ac9a37e931 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/ProjectLevelTypeTable.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/ProjectLevelTypeTable.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/TypeTable.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/TypeTable.java
index 025b8ff8cb..45f9a860e9 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/TypeTable.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/TypeTable.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/package-info.java b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/package-info.java
index 0f7d1b9c94..94fabf403a 100644
--- a/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/semantic/v2/typetable/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tests/UnittestUtils.java b/python-frontend/src/main/java/org/sonar/python/tests/UnittestUtils.java
deleted file mode 100644
index 4a304c4178..0000000000
--- a/python-frontend/src/main/java/org/sonar/python/tests/UnittestUtils.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the Sonar Source-Available License for more details.
- *
- * You should have received a copy of the Sonar Source-Available License
- * along with this program; if not, see https://sonarsource.com/license/ssal/
- */
-package org.sonar.python.tests;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import org.sonar.plugins.python.api.tree.ClassDef;
-import org.sonar.plugins.python.api.tree.Tree;
-import org.sonar.python.tree.TreeUtils;
-
-public class UnittestUtils {
-
-  private UnittestUtils() {
-
-  }
-
-  // Methods of unittest are the union of Python 2 and Python 3 methods:
-  // https://docs.python.org/2/library/unittest.html#unittest.TestCase
-  // https://docs.python.org/3/library/unittest.html#unittest.TestCase
-  public static final Set RUN_METHODS = Set.of("setUp", "tearDown", "setUpClass", "tearDownClass", "run", "skiptTest",
-    "subTest", "debug", "asyncSetUp", "asyncTearDown");
-
-  public static final Set RAISE_METHODS = Set.of("assertRaises", "assertRaisesRegexp", "assertRaisesRegex");
-
-  public static final Set ASSERTIONS_METHODS = Set.of("assertEqual", "assertNotEqual", "assertTrue", "assertFalse", "assertIs",
-    "assertIsNot", "assertIsNone", "assertIsNotNone", "assertIn", "assertNotIn", "assertIsInstance", "assertNotIsInstance",
-    "assertAlmostEqual", "assertNotAlmostEqual", "assertGreater", "assertGreaterEqual", "assertLess", "assertLessEqual",
-    "assertRegexpMatches", "assertNotRegexpMatches", "assertItemsEqual", "assertDictContainsSubset", "assertMultiLineEqual",
-    "assertSequenceEqual", "assertListEqual", "assertTupleEqual", "assertSetEqual", "assertDictEqual", "assertWarns", "assertWarnsRegex",
-    "assertLogs", "assertNoLogs", "assertRegex", "assertNotRegex", "assertCountEqual");
-
-
-  public static final Set UTIL_METHODS = Set.of("addTypeEqualityFunc", "fail", "failureException", "longMessage", "maxDiff");
-
-  public static final Set GATHER_INFO_METHODS = Set.of("countTestCases", "defaultTestResult", "id", "shortDescription", "addCleanup",
-    "doCleanups", "addClassCleanup", "doClassCleanups");
-
-  private static final Set ALL_METHODS = new HashSet<>();
-  private static final Set ALL_ASSERT_METHODS = new HashSet<>();
-
-  static {
-    ALL_METHODS.addAll(RUN_METHODS);
-    ALL_METHODS.addAll(UTIL_METHODS);
-    ALL_METHODS.addAll(GATHER_INFO_METHODS);
-    ALL_METHODS.addAll(ASSERTIONS_METHODS);
-    ALL_METHODS.addAll(RAISE_METHODS);
-    ALL_ASSERT_METHODS.addAll(ASSERTIONS_METHODS);
-    ALL_ASSERT_METHODS.addAll(RAISE_METHODS);
-  }
-
-  public static Set allMethods() {
-    return Collections.unmodifiableSet(ALL_METHODS);
-  }
-  public static Set allAssertMethods() {
-    return Collections.unmodifiableSet(ALL_ASSERT_METHODS);
-  }
-
-  public static boolean isWithinUnittestTestCase(Tree tree) {
-    List parentClassesFQN = new ArrayList<>();
-    ClassDef classDef = (ClassDef) TreeUtils.firstAncestorOfKind(tree, Tree.Kind.CLASSDEF);
-    if (classDef != null) {
-      parentClassesFQN.addAll(TreeUtils.getParentClassesFQN(classDef));
-    }
-    return parentClassesFQN.stream().anyMatch(parentClass -> parentClass.contains("unittest") && parentClass.contains("TestCase"));
-  }
-}
diff --git a/python-frontend/src/main/java/org/sonar/python/tests/package-info.java b/python-frontend/src/main/java/org/sonar/python/tests/package-info.java
index 0ed651f507..ebc1f01059 100644
--- a/python-frontend/src/main/java/org/sonar/python/tests/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/tests/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/AliasedNameImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/AliasedNameImpl.java
index ee3cecad33..ba3e02f84e 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/AliasedNameImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/AliasedNameImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/AnnotatedAssignmentImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/AnnotatedAssignmentImpl.java
index 2e828c48b3..0f58436cc4 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/AnnotatedAssignmentImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/AnnotatedAssignmentImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ArgListImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ArgListImpl.java
index 5a89e6f172..2de62bf863 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ArgListImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ArgListImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/AsPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/AsPatternImpl.java
index dec95f3d35..e3cb08af4a 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/AsPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/AsPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/AssertStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/AssertStatementImpl.java
index c926058e73..60bb282369 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/AssertStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/AssertStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/AssignmentExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/AssignmentExpressionImpl.java
index 63c5251cad..6cbe16f246 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/AssignmentExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/AssignmentExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/AssignmentStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/AssignmentStatementImpl.java
index edec91daf5..513c45ea11 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/AssignmentStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/AssignmentStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/AwaitExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/AwaitExpressionImpl.java
index 9abbc31fd5..ac9638811a 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/AwaitExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/AwaitExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/BinaryExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/BinaryExpressionImpl.java
index 35b5c1d5d6..399a73cf9a 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/BinaryExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/BinaryExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/BreakStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/BreakStatementImpl.java
index 60160224ee..923bcce490 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/BreakStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/BreakStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/CallExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/CallExpressionImpl.java
index a0e4cfe98f..cd85dbc7c3 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/CallExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/CallExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/CapturePatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/CapturePatternImpl.java
index 527737d7b2..1b2cde5eed 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/CapturePatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/CapturePatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/CaseBlockImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/CaseBlockImpl.java
index 75c213e4f2..1bced8caa9 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/CaseBlockImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/CaseBlockImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/CellMagicStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/CellMagicStatementImpl.java
index 20b744a025..86c37ac9c6 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/CellMagicStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/CellMagicStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ClassDefImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ClassDefImpl.java
index aa5c293e85..58313e098a 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ClassDefImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ClassDefImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ClassPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ClassPatternImpl.java
index f790c785c2..f86d26f8cc 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ClassPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ClassPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/CompoundAssignmentStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/CompoundAssignmentStatementImpl.java
index c37c09e1a5..67b543e1b8 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/CompoundAssignmentStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/CompoundAssignmentStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionExpressionImpl.java
index 3e18039090..e1ddd52fd4 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionForImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionForImpl.java
index 48c52f6807..87643f06c9 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionForImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionForImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionIfImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionIfImpl.java
index 9067152e6f..dd174b4b83 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionIfImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ComprehensionIfImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ConditionalExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ConditionalExpressionImpl.java
index 63e3be954e..0322cda0e8 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ConditionalExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ConditionalExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ContinueStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ContinueStatementImpl.java
index 2ac28215fe..0fb8f5884a 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ContinueStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ContinueStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/DecoratorImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/DecoratorImpl.java
index 27702c5d94..5127c59338 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/DecoratorImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/DecoratorImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/DelStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/DelStatementImpl.java
index 0f2c0e5824..ffcf9c4d81 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/DelStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/DelStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/DictCompExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/DictCompExpressionImpl.java
index 11a62ef34f..b671148329 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/DictCompExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/DictCompExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/DictOrSetLiteralImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/DictOrSetLiteralImpl.java
index 5c139a9e2e..09135ff69a 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/DictOrSetLiteralImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/DictOrSetLiteralImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/DictionaryLiteralImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/DictionaryLiteralImpl.java
index a05e1f886b..9011e24084 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/DictionaryLiteralImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/DictionaryLiteralImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/DottedNameImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/DottedNameImpl.java
index 86745515cd..2a52663486 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/DottedNameImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/DottedNameImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/DoubleStarPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/DoubleStarPatternImpl.java
index 8fd8068496..284f446548 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/DoubleStarPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/DoubleStarPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/DynamicObjectInfoStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/DynamicObjectInfoStatementImpl.java
index 09a5fecb8e..6ca2e3f6b7 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/DynamicObjectInfoStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/DynamicObjectInfoStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/EllipsisExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/EllipsisExpressionImpl.java
index 90698123e2..b819015bd3 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/EllipsisExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/EllipsisExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ElseClauseImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ElseClauseImpl.java
index f0a9d12b94..ff4f865bbf 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ElseClauseImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ElseClauseImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ExceptClauseImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ExceptClauseImpl.java
index 67276d9454..690f82f771 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ExceptClauseImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ExceptClauseImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ExceptGroupJumpInstructionsCheck.java b/python-frontend/src/main/java/org/sonar/python/tree/ExceptGroupJumpInstructionsCheck.java
index feaa800345..2313260ee1 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ExceptGroupJumpInstructionsCheck.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ExceptGroupJumpInstructionsCheck.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ExecStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ExecStatementImpl.java
index b47b164c44..f51763dadc 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ExecStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ExecStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ExpressionListImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ExpressionListImpl.java
index 041326320b..e13d1c1df4 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ExpressionListImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ExpressionListImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ExpressionStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ExpressionStatementImpl.java
index 6a9dd77af4..da437744a9 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ExpressionStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ExpressionStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/FileInputImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/FileInputImpl.java
index 906ea2a4f6..0d3da11ffd 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/FileInputImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/FileInputImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/FinallyClauseImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/FinallyClauseImpl.java
index 2019b63cdb..933baead3c 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/FinallyClauseImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/FinallyClauseImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ForStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ForStatementImpl.java
index ccd212c9fa..754eb54ae5 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ForStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ForStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/FormatSpecifierImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/FormatSpecifierImpl.java
index 25774f7101..2196712e56 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/FormatSpecifierImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/FormatSpecifierImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/FormattedExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/FormattedExpressionImpl.java
index d49005c3ec..ec3edf3ccb 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/FormattedExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/FormattedExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/FunctionDefImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/FunctionDefImpl.java
index 72713be886..5565f899f0 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/FunctionDefImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/FunctionDefImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/GlobalStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/GlobalStatementImpl.java
index ab6160fc94..9361c2e610 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/GlobalStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/GlobalStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/GroupPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/GroupPatternImpl.java
index c2c7524509..bfa6e023e7 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/GroupPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/GroupPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/GuardImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/GuardImpl.java
index 0631477419..8dde1a6cca 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/GuardImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/GuardImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/IPythonTreeMaker.java b/python-frontend/src/main/java/org/sonar/python/tree/IPythonTreeMaker.java
index 5fcf2ad408..a8f3bb9865 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/IPythonTreeMaker.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/IPythonTreeMaker.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/IfStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/IfStatementImpl.java
index 221c309cbb..a6794cafd7 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/IfStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/IfStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ImportFromImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ImportFromImpl.java
index 7772420199..798abab554 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ImportFromImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ImportFromImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ImportNameImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ImportNameImpl.java
index 0a82c80c9e..75ff16e254 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ImportNameImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ImportNameImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/InExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/InExpressionImpl.java
index b53c71e7f3..675d28e2cd 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/InExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/InExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/IsExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/IsExpressionImpl.java
index a44f555c5c..66fbe4f551 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/IsExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/IsExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/KeyValuePairImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/KeyValuePairImpl.java
index aec71e5c0d..ad0557d565 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/KeyValuePairImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/KeyValuePairImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/KeyValuePatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/KeyValuePatternImpl.java
index c38a714d10..77e67a574e 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/KeyValuePatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/KeyValuePatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/KeywordPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/KeywordPatternImpl.java
index 7b04c1d233..e70533df92 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/KeywordPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/KeywordPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/LambdaExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/LambdaExpressionImpl.java
index cdb99d5bb5..80ce3e3ddc 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/LambdaExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/LambdaExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/LineMagicImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/LineMagicImpl.java
index 218362d058..23014f8941 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/LineMagicImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/LineMagicImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ListLiteralImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ListLiteralImpl.java
index a37d21e1cd..cd6a75701d 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ListLiteralImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ListLiteralImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/LiteralPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/LiteralPatternImpl.java
index 8f6714ffd9..ce12ad8e57 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/LiteralPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/LiteralPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/MappingPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/MappingPatternImpl.java
index 043cab7c19..feae226b12 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/MappingPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/MappingPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/MatchStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/MatchStatementImpl.java
index dff15d80ce..20ee3fe99a 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/MatchStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/MatchStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/NameImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/NameImpl.java
index c719819977..25655a1cd3 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/NameImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/NameImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/NoneExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/NoneExpressionImpl.java
index 74d5a2923b..e71f55f0a3 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/NoneExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/NoneExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/NonlocalStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/NonlocalStatementImpl.java
index 4e6ec8a797..ace2db5ef4 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/NonlocalStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/NonlocalStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/NumericLiteralImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/NumericLiteralImpl.java
index cbc631bd36..4c2fe88df6 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/NumericLiteralImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/NumericLiteralImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,6 +16,7 @@
  */
 package org.sonar.python.tree;
 
+import java.math.BigDecimal;
 import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
@@ -61,6 +62,17 @@ public long valueAsLong() {
       return Integer.valueOf(literalValue.substring(2), 8);
     } else if (literalValue.startsWith("0x") || literalValue.startsWith("0X")) {
       return Integer.valueOf(literalValue.substring(2), 16);
+    } else if (numericKind() == NumericKind.FLOAT) {
+      // Decimal floats (e.g. 0.0, 1e3) must be handled before legacy octal (0-prefixed),
+      // otherwise tokens like "0.0" match the octal branch and ".0" is parsed as base 8.
+      try {
+        return new BigDecimal(literalValue).longValueExact();
+      } catch (ArithmeticException e) {
+        NumberFormatException nfe = new NumberFormatException(
+          "Not an integral floating-point literal: " + literalValue);
+        nfe.initCause(e);
+        throw nfe;
+      }
     } else if (literalValue.startsWith("0") && literalValue.length() > 1) {
       // Python 2 syntax (https://www.python.org/dev/peps/pep-3127/#removal-of-old-octal-syntax)
       return Integer.valueOf(literalValue.substring(1), 8);
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/OrPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/OrPatternImpl.java
index 1d5d86057b..96ab2fcf42 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/OrPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/OrPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ParameterImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ParameterImpl.java
index d61c98b758..ea37197552 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ParameterImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ParameterImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ParameterListImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ParameterListImpl.java
index a3ea6d3fb0..b5e7ed07d6 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ParameterListImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ParameterListImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ParenthesizedExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ParenthesizedExpressionImpl.java
index cdf40a92e4..dcbf900e14 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ParenthesizedExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ParenthesizedExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/PassStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/PassStatementImpl.java
index 288dae205e..5a1fbe1fad 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/PassStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/PassStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/PrintStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/PrintStatementImpl.java
index 7892fbc7f5..f7f779edb7 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/PrintStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/PrintStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/PyTree.java b/python-frontend/src/main/java/org/sonar/python/tree/PyTree.java
index b3bc425edf..1072c51a48 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/PyTree.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/PyTree.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/PythonTreeMaker.java b/python-frontend/src/main/java/org/sonar/python/tree/PythonTreeMaker.java
index b48b102be3..50d6ddb1e6 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/PythonTreeMaker.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/PythonTreeMaker.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/PythonTreeMakerUtils.java b/python-frontend/src/main/java/org/sonar/python/tree/PythonTreeMakerUtils.java
index a70327291e..d9db5d6e01 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/PythonTreeMakerUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/PythonTreeMakerUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/QualifiedExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/QualifiedExpressionImpl.java
index f628416e51..01c01a034f 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/QualifiedExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/QualifiedExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/RaiseStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/RaiseStatementImpl.java
index 9a22b1d53e..5395c57a0f 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/RaiseStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/RaiseStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/RegularArgumentImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/RegularArgumentImpl.java
index 50bc594e2c..63349c7b0f 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/RegularArgumentImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/RegularArgumentImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ReprExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ReprExpressionImpl.java
index 98df10ffb0..33894b7666 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ReprExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ReprExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ReturnStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ReturnStatementImpl.java
index 6fbf126df3..d50676e4fb 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ReturnStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ReturnStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/Separators.java b/python-frontend/src/main/java/org/sonar/python/tree/Separators.java
index fa82057123..9ead255a0f 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/Separators.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/Separators.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/SequencePatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/SequencePatternImpl.java
index 20720a5377..dd7fbc8c45 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/SequencePatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/SequencePatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/SetLiteralImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/SetLiteralImpl.java
index f7d8c7ae98..e5962bef5b 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/SetLiteralImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/SetLiteralImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/SimpleStatement.java b/python-frontend/src/main/java/org/sonar/python/tree/SimpleStatement.java
index 90cb7bc7e4..c70477eb9d 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/SimpleStatement.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/SimpleStatement.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/SliceExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/SliceExpressionImpl.java
index 15081b06df..274d55d0fb 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/SliceExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/SliceExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/SliceItemImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/SliceItemImpl.java
index 4f1d4574d7..f1e9a0a4f0 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/SliceItemImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/SliceItemImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/SliceListImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/SliceListImpl.java
index 336b7a3733..26973747b5 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/SliceListImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/SliceListImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/StarPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/StarPatternImpl.java
index 68e78b436c..fb22398d0c 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/StarPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/StarPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/StatementListImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/StatementListImpl.java
index 161ce9e079..b89fab3de8 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/StatementListImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/StatementListImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/StatementWithSeparator.java b/python-frontend/src/main/java/org/sonar/python/tree/StatementWithSeparator.java
index 7851c7c79a..9fb5f5d7a1 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/StatementWithSeparator.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/StatementWithSeparator.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/StringElementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/StringElementImpl.java
index bec4b59bd6..0ecc4b1b76 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/StringElementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/StringElementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/StringLiteralImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/StringLiteralImpl.java
index 94ff30c5e7..271f3121be 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/StringLiteralImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/StringLiteralImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -90,4 +90,14 @@ public void typeV2(PythonType type) {
   public boolean isTemplate() {
     return !stringElements.isEmpty() && stringElements.stream().anyMatch(StringElement::isTemplate);
   }
+
+  /**
+   * @return {@code true} if this literal is a bytes literal (e.g. {@code b'...'}), as opposed to a
+   * str literal. Implicitly-concatenated adjacent literals (e.g. {@code b'a' b'b'}) can only mix
+   * bytes with bytes or str with str, so it is enough to check that every element carries a bytes
+   * prefix.
+   */
+  public boolean isBytes() {
+    return !stringElements.isEmpty() && stringElements.stream().allMatch(e -> BYTES_PREFIXES.contains(e.prefix()));
+  }
 }
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/SubscriptionExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/SubscriptionExpressionImpl.java
index af75fbec5e..ca21f58c8e 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/SubscriptionExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/SubscriptionExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TokenEnricher.java b/python-frontend/src/main/java/org/sonar/python/tree/TokenEnricher.java
index bafab53d99..5ac3b993ec 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TokenEnricher.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TokenEnricher.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TokenImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/TokenImpl.java
index 82494b6092..c210f79485 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TokenImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TokenImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TreeUtils.java b/python-frontend/src/main/java/org/sonar/python/tree/TreeUtils.java
index baaba5bc73..61f668b9dc 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TreeUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TreeUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -62,6 +62,7 @@
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.tree.Tree.Kind;
 import org.sonar.plugins.python.api.tree.Tuple;
+import org.sonar.plugins.python.api.tree.UnpackingExpression;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.python.api.PythonTokenType;
 
@@ -171,7 +172,7 @@ public static ClassSymbol getClassSymbolFromDef(@Nullable ClassDef classDef) {
 
   @CheckForNull
   public static ClassDef getEnclosingClassDef(Tree tree) {
-    Tree enclosingClass = firstAncestorOfKind(tree, Tree.Kind.CLASSDEF, Tree.Kind.FUNCDEF);
+    Tree enclosingClass = firstAncestorOfKind(tree, Tree.Kind.CLASSDEF, Tree.Kind.FUNCDEF, Tree.Kind.LAMBDA);
     if (enclosingClass instanceof ClassDef classDef) {
       return classDef;
     }
@@ -634,6 +635,21 @@ public static Set getLocalVariableSymbols(FunctionDef functionDef) {
       .collect(Collectors.toSet());
   }
 
+  /**
+   * Checks if a tree node represents a double-star ({@code **}) expression.
+   * Supports both {@link Parameter} (e.g. {@code **kwargs} in function definitions)
+   * and {@link UnpackingExpression} (e.g. {@code **kwargs} in call arguments).
+   */
+  public static boolean isDoubleStarExpression(Tree tree) {
+    Token starToken = null;
+    if (tree instanceof Parameter parameter) {
+      starToken = parameter.starToken();
+    } else if (tree instanceof UnpackingExpression unpackingExpression) {
+      starToken = unpackingExpression.starToken();
+    }
+    return starToken != null && "**".equals(starToken.value());
+  }
+
   private static final Pattern CONSTANT_NAME_PATTERN = Pattern.compile("^[_A-Z][A-Z0-9_]*$");
 
   public static boolean isConstantName(String name) {
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TriviaImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/TriviaImpl.java
index 1e96667b4e..ae97cf86a0 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TriviaImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TriviaImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TryStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/TryStatementImpl.java
index 6d711541bf..5a20278221 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TryStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TryStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TupleImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/TupleImpl.java
index c909eef146..7c6f68afde 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TupleImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TupleImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TupleParameterImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/TupleParameterImpl.java
index 28d1a8bc69..8b08b54f3d 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TupleParameterImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TupleParameterImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TypeAliasStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/TypeAliasStatementImpl.java
index 662d46de91..e7b9332703 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TypeAliasStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TypeAliasStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TypeAnnotationImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/TypeAnnotationImpl.java
index 7dce566f6f..c549583667 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TypeAnnotationImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TypeAnnotationImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TypeParamImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/TypeParamImpl.java
index 82cdbb46f1..fc2a3c445e 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TypeParamImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TypeParamImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/TypeParamsImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/TypeParamsImpl.java
index b83937c395..b84ce36bf0 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/TypeParamsImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/TypeParamsImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/UnaryExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/UnaryExpressionImpl.java
index 22eb59fe00..0e786e61e0 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/UnaryExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/UnaryExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/UnpackingExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/UnpackingExpressionImpl.java
index 2535702a38..fa357d54db 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/UnpackingExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/UnpackingExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/ValuePatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/ValuePatternImpl.java
index a59aba3618..d974bf2108 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/ValuePatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/ValuePatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/WhileStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/WhileStatementImpl.java
index 90360287d1..1b53e0055b 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/WhileStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/WhileStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/WildcardPatternImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/WildcardPatternImpl.java
index 469e815087..23531e2479 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/WildcardPatternImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/WildcardPatternImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/WithStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/WithStatementImpl.java
index 248870b7ac..5ee095de92 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/WithStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/WithStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/YieldExpressionImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/YieldExpressionImpl.java
index 8ee5038fbe..d9c734e380 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/YieldExpressionImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/YieldExpressionImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/YieldStatementImpl.java b/python-frontend/src/main/java/org/sonar/python/tree/YieldStatementImpl.java
index 48a3d15712..7b9409ec15 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/YieldStatementImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/YieldStatementImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/tree/package-info.java b/python-frontend/src/main/java/org/sonar/python/tree/package-info.java
index d0220493d8..8281ea18b0 100644
--- a/python-frontend/src/main/java/org/sonar/python/tree/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/tree/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/AnyType.java b/python-frontend/src/main/java/org/sonar/python/types/AnyType.java
index e017c9d62a..7cbbd96422 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/AnyType.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/AnyType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/DeclaredType.java b/python-frontend/src/main/java/org/sonar/python/types/DeclaredType.java
index c2cdc66f23..4edb5a0bd3 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/DeclaredType.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/DeclaredType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/FlowSensitiveTypeInference.java b/python-frontend/src/main/java/org/sonar/python/types/FlowSensitiveTypeInference.java
index 21fb7f160a..2ba9d48d25 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/FlowSensitiveTypeInference.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/FlowSensitiveTypeInference.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/HasTypeDependencies.java b/python-frontend/src/main/java/org/sonar/python/types/HasTypeDependencies.java
index d7782eaa8e..72b4f9146d 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/HasTypeDependencies.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/HasTypeDependencies.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/InferredTypes.java b/python-frontend/src/main/java/org/sonar/python/types/InferredTypes.java
index 6380cba33a..9c67520494 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/InferredTypes.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/InferredTypes.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/RuntimeType.java b/python-frontend/src/main/java/org/sonar/python/types/RuntimeType.java
index 4df9c2afc6..fea4273e1f 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/RuntimeType.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/RuntimeType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/TypeInference.java b/python-frontend/src/main/java/org/sonar/python/types/TypeInference.java
index b14b9422e0..1cd1180a6f 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/TypeInference.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/TypeInference.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/TypeInferenceProgramState.java b/python-frontend/src/main/java/org/sonar/python/types/TypeInferenceProgramState.java
index 1aaa7fccf0..5d5accabdb 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/TypeInferenceProgramState.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/TypeInferenceProgramState.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/TypeShed.java b/python-frontend/src/main/java/org/sonar/python/types/TypeShed.java
index d87ae75fbd..56c6b3d112 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/TypeShed.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/TypeShed.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -64,7 +64,6 @@ public class TypeShed {
 
   private static volatile Map builtins;
   private static final Map> typeShedSymbols = new ConcurrentHashMap<>();
-  private static final Map> builtinGlobalSymbols = new ConcurrentHashMap<>();
   private static final ReentrantLock resolutionLock = new ReentrantLock();
 
   private static final String PROTOBUF_CUSTOM_STUBS = "custom_protobuf/";
@@ -112,10 +111,9 @@ public static Map builtinSymbols() {
       try {
         if (builtins == null) {
           supportedPythonVersions = ProjectPythonVersion.currentVersions().stream().map(PythonVersionUtils.Version::serializedValue).collect(Collectors.toSet());
-          Map builtinMap = getSymbolsFromProtobufModule(BUILTINS_FQN, PROTOBUF);
+          Map builtinMap = new HashMap<>(getSymbolsFromProtobufModule(BUILTINS_FQN, PROTOBUF));
           builtinMap.put(NONE_TYPE, new ClassSymbolImpl(NONE_TYPE, NONE_TYPE));
           builtins = Collections.unmodifiableMap(builtinMap);
-          builtinGlobalSymbols.put("", new HashSet<>(builtinMap.values()));
         }
       } finally {
         resolutionLock.unlock();
@@ -316,17 +314,26 @@ public static SymbolsProtos.ClassSymbol classDescriptorWithFQN(String fullyQuali
     return null;
   }
 
+  /**
+   * Invalidates cached Typeshed symbols from the previous analysis, then eagerly rebuilds the builtin symbols and
+   * supported Python version set for the current analysis.
+   */
+  public static void resetBuiltinSymbols() {
+    resolutionLock.lock();
+    try {
+      builtins = null;
+      typeShedSymbols.clear();
+      supportedPythonVersions = null;
+      builtinSymbols();
+    } finally {
+      resolutionLock.unlock();
+    }
+  }
+
   //================================================================================
   // Private methods
   //================================================================================
 
-  // used by tests whenever 'sonar.python.version' changes
-  public static void resetBuiltinSymbols() {
-    builtins = null;
-    typeShedSymbols.clear();
-    builtinSymbols();
-  }
-
   private static Map searchTypeShedForModule(String moduleName, Set modulesInProgress) {
     if (modulesInProgress.contains(moduleName)) {
       return new HashMap<>();
diff --git a/python-frontend/src/main/java/org/sonar/python/types/UnionType.java b/python-frontend/src/main/java/org/sonar/python/types/UnionType.java
index 727c4e0f0d..6753442a1e 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/UnionType.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/UnionType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/UnknownClassType.java b/python-frontend/src/main/java/org/sonar/python/types/UnknownClassType.java
index e99e3cfa2f..d08175285f 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/UnknownClassType.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/UnknownClassType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/package-info.java b/python-frontend/src/main/java/org/sonar/python/types/package-info.java
index 03e352c7cf..ae8b327d93 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/LazyType.java b/python-frontend/src/main/java/org/sonar/python/types/v2/LazyType.java
index 3b7758b851..ebb5c03441 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/LazyType.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/LazyType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/LazyTypeWrapper.java b/python-frontend/src/main/java/org/sonar/python/types/v2/LazyTypeWrapper.java
index 00cca1359f..e14954d27c 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/LazyTypeWrapper.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/LazyTypeWrapper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/LazyUnionType.java b/python-frontend/src/main/java/org/sonar/python/types/v2/LazyUnionType.java
index 8d02a1d658..45efb7502c 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/LazyUnionType.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/LazyUnionType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/ResolvableType.java b/python-frontend/src/main/java/org/sonar/python/types/v2/ResolvableType.java
index 2c6561aeb5..cb8349c7b0 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/ResolvableType.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/ResolvableType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/SimpleTypeWrapper.java b/python-frontend/src/main/java/org/sonar/python/types/v2/SimpleTypeWrapper.java
index ac661bfcde..123f562cec 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/SimpleTypeWrapper.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/SimpleTypeWrapper.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/SpecialFormType.java b/python-frontend/src/main/java/org/sonar/python/types/v2/SpecialFormType.java
index 431c68ba03..3f36cdc1f3 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/SpecialFormType.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/SpecialFormType.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/TypeCheckBuilder.java b/python-frontend/src/main/java/org/sonar/python/types/v2/TypeCheckBuilder.java
index 09111d05ad..e6f2a37a2d 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/TypeCheckBuilder.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/TypeCheckBuilder.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/TypeCheckMap.java b/python-frontend/src/main/java/org/sonar/python/types/v2/TypeCheckMap.java
index dcdcb95903..6cd15003e7 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/TypeCheckMap.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/TypeCheckMap.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/TypeChecker.java b/python-frontend/src/main/java/org/sonar/python/types/v2/TypeChecker.java
index 89f4bdc62f..bfb1e4a877 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/TypeChecker.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/TypeChecker.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/TypeUtils.java b/python-frontend/src/main/java/org/sonar/python/types/v2/TypeUtils.java
index 77885311b4..a2d8ddbbe9 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/TypeUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/TypeUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/AllTypePredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/AllTypePredicate.java
index 2f99cfb89e..5734e4f298 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/AllTypePredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/AllTypePredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/AnyTypePredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/AnyTypePredicate.java
index f83de6de8c..9db0288628 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/AnyTypePredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/AnyTypePredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasFQNPredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasFQNPredicate.java
index 5e66b00294..37ff0d8f7b 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasFQNPredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasFQNPredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasFQNSatisfyingPredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasFQNSatisfyingPredicate.java
new file mode 100644
index 0000000000..98496c5ba9
--- /dev/null
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasFQNSatisfyingPredicate.java
@@ -0,0 +1,44 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.types.v2.matchers;
+
+import java.util.Optional;
+import java.util.function.Function;
+import org.sonar.plugins.python.api.TriBool;
+import org.sonar.plugins.python.api.types.v2.FullyQualifiedNameHelper;
+import org.sonar.plugins.python.api.types.v2.PythonType;
+
+/**
+ * Matches types whose FQN satisfies the given predicate.
+ * Prefer convenience factories such as {@code TypeMatchers.withFQNPrefix} when applicable.
+ */
+public class HasFQNSatisfyingPredicate implements TypePredicate {
+
+  private final Function fqnPredicate;
+
+  public HasFQNSatisfyingPredicate(Function fqnPredicate) {
+    this.fqnPredicate = fqnPredicate;
+  }
+
+  @Override
+  public TriBool check(PythonType type, TypePredicateContext ctx) {
+    return Optional.of(type)
+      .flatMap(FullyQualifiedNameHelper::getFullyQualifiedName)
+      .map(fqnPredicate)
+      .orElse(TriBool.UNKNOWN);
+  }
+}
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasMemberPredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasMemberPredicate.java
index 21517f4df8..f8d0190577 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasMemberPredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasMemberPredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasMemberSatisfyingPredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasMemberSatisfyingPredicate.java
index ba995ad81c..156155947b 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasMemberSatisfyingPredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/HasMemberSatisfyingPredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/InternalTypeMatchers.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/InternalTypeMatchers.java
index c89bce4f79..64a20e16f6 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/InternalTypeMatchers.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/InternalTypeMatchers.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsAnyTypeInUnionSatisfying.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsAnyTypeInUnionSatisfying.java
index c56a34d8f4..acaccd821e 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsAnyTypeInUnionSatisfying.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsAnyTypeInUnionSatisfying.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsFunctionOwnerSatisfyingPredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsFunctionOwnerSatisfyingPredicate.java
index 765dae4df0..09361eee30 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsFunctionOwnerSatisfyingPredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsFunctionOwnerSatisfyingPredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsObjectSatisfyingPredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsObjectSatisfyingPredicate.java
index 0d25cf5528..99c046cf93 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsObjectSatisfyingPredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsObjectSatisfyingPredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsSelfTypePredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsSelfTypePredicate.java
index 6b19ac56ec..06e66f4cb5 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsSelfTypePredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsSelfTypePredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsTypeOrSuperTypeSatisfyingPredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsTypeOrSuperTypeSatisfyingPredicate.java
index 0f50186190..83cf642727 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsTypeOrSuperTypeSatisfyingPredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsTypeOrSuperTypeSatisfyingPredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsTypePredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsTypePredicate.java
index 91f6639c4d..4c55ba0e40 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsTypePredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/IsTypePredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypeMatcherImpl.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypeMatcherImpl.java
index a42c2da754..92f316db32 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypeMatcherImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypeMatcherImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicate.java
index 7198522498..edcdfdf725 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateContext.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateContext.java
index d5057008b6..0d60d4203e 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateContext.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateContext.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateContextImpl.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateContextImpl.java
index c82a4f5110..6c9047f988 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateContextImpl.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateContextImpl.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateUtils.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateUtils.java
index 0711fd9463..dde26ffe52 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateUtils.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypePredicateUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypeSourcePredicate.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypeSourcePredicate.java
index 2b8bf3eaf9..c8010e0b90 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypeSourcePredicate.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/TypeSourcePredicate.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/package-info.java b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/package-info.java
index 80343ef25f..de6fd181dd 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/matchers/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/java/org/sonar/python/types/v2/package-info.java b/python-frontend/src/main/java/org/sonar/python/types/v2/package-info.java
index a991c740fa..30709e8721 100644
--- a/python-frontend/src/main/java/org/sonar/python/types/v2/package-info.java
+++ b/python-frontend/src/main/java/org/sonar/python/types/v2/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/_pytest.fixtures.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/_pytest.fixtures.protobuf
new file mode 100644
index 0000000000..179dfd9c16
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/_pytest.fixtures.protobuf
@@ -0,0 +1,19 @@
+
+_pytest.fixtures
+FixtureRequest_pytest.fixtures.FixtureRequest"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+getfixturevalue/_pytest.fixtures.FixtureRequest.getfixturevalue""
+builtins.object"builtins.object*L
+selfB
+_pytest.fixtures.FixtureRequest"_pytest.fixtures.FixtureRequest*)
+argname
+builtins.str"builtins.str*
+addfinalizer,_pytest.fixtures.FixtureRequest.addfinalizer"
+None*L
+selfB
+_pytest.fixtures.FixtureRequest"_pytest.fixtures.FixtureRequest*1
+	finalizer"
+builtins.object"builtins.object*
+__annotations__ _pytest.fixtures.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/_pytest.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/_pytest.protobuf
new file mode 100644
index 0000000000..38417e9d5c
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/_pytest.protobuf
@@ -0,0 +1,9 @@
+
+_pytest*h
+__path___pytest.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations___pytest.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.decorators.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.decorators.protobuf
new file mode 100644
index 0000000000..b9d0e992b3
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.decorators.protobuf
@@ -0,0 +1,16 @@
+
+airflow.decorators
+dagairflow.decorators.dag"K
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+args
+Any*
+kwargs
+Any*s
+__path__airflow.decorators.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__"airflow.decorators.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.baseoperator.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.baseoperator.protobuf
new file mode 100644
index 0000000000..72ee0ce400
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.baseoperator.protobuf
@@ -0,0 +1,15 @@
+
+airflow.models.baseoperator
+BaseOperator(airflow.models.baseoperator.BaseOperator"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__1airflow.models.baseoperator.BaseOperator.__init__"
+None*^
+selfT
+(airflow.models.baseoperator.BaseOperator"(airflow.models.baseoperator.BaseOperator*
+args
+Any*
+kwargs
+Any*
+__annotations__+airflow.models.baseoperator.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.dag.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.dag.protobuf
new file mode 100644
index 0000000000..63997e7e01
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.dag.protobuf
@@ -0,0 +1,15 @@
+
+airflow.models.dag
+DAGairflow.models.dag.DAG"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__airflow.models.dag.DAG.__init__"
+None*:
+self0
+airflow.models.dag.DAG"airflow.models.dag.DAG*
+args
+Any*
+kwargs
+Any*
+__annotations__"airflow.models.dag.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.protobuf
new file mode 100644
index 0000000000..a1a891521d
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.protobuf
@@ -0,0 +1,36 @@
+
+airflow.models
+BaseOperator(airflow.models.baseoperator.BaseOperator"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__1airflow.models.baseoperator.BaseOperator.__init__"
+None*^
+selfT
+(airflow.models.baseoperator.BaseOperator"(airflow.models.baseoperator.BaseOperator*
+args
+Any*
+kwargs
+Any
+DAGairflow.models.dag.DAG"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__airflow.models.dag.DAG.__init__"
+None*:
+self0
+airflow.models.dag.DAG"airflow.models.dag.DAG*
+args
+Any*
+kwargs
+Any
+DependencyMixin(airflow.models.taskmixin.DependencyMixin"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__1airflow.models.taskmixin.DependencyMixin.__init__"
+None*^
+selfT
+(airflow.models.taskmixin.DependencyMixin"(airflow.models.taskmixin.DependencyMixin*
+args
+Any*
+kwargs
+Any*o
+__path__airflow.models.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__airflow.models.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.taskmixin.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.taskmixin.protobuf
new file mode 100644
index 0000000000..99773b9c98
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.models.taskmixin.protobuf
@@ -0,0 +1,15 @@
+
+airflow.models.taskmixin
+DependencyMixin(airflow.models.taskmixin.DependencyMixin"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__1airflow.models.taskmixin.DependencyMixin.__init__"
+None*^
+selfT
+(airflow.models.taskmixin.DependencyMixin"(airflow.models.taskmixin.DependencyMixin*
+args
+Any*
+kwargs
+Any*
+__annotations__(airflow.models.taskmixin.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.protobuf
new file mode 100644
index 0000000000..152542d532
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.protobuf
@@ -0,0 +1,27 @@
+
+airflow
+DAGairflow.models.dag.DAG"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__airflow.models.dag.DAG.__init__"
+None*:
+self0
+airflow.models.dag.DAG"airflow.models.dag.DAG*
+args
+Any*
+kwargs
+Any
+BaseOperator(airflow.models.baseoperator.BaseOperator"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__1airflow.models.baseoperator.BaseOperator.__init__"
+None*^
+selfT
+(airflow.models.baseoperator.BaseOperator"(airflow.models.baseoperator.BaseOperator*
+args
+Any*
+kwargs
+Any*h
+__path__airflow.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__airflow.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.aws.operators.ecs.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.aws.operators.ecs.protobuf
new file mode 100644
index 0000000000..715a0b1047
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.aws.operators.ecs.protobuf
@@ -0,0 +1,15 @@
+
+*airflow.providers.amazon.aws.operators.ecs
+EcsRunTaskOperator=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"(airflow.models.baseoperator.BaseOperator*
+__init__Fairflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator.__init__"
+None*
+self~
+=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator*
+args
+Any*
+kwargs
+Any*
+__annotations__:airflow.providers.amazon.aws.operators.ecs.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.aws.operators.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.aws.operators.protobuf
new file mode 100644
index 0000000000..def6fe28b5
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.aws.operators.protobuf
@@ -0,0 +1,18 @@
+
+&airflow.providers.amazon.aws.operators
+EcsRunTaskOperator=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"(airflow.models.baseoperator.BaseOperator*
+__init__Fairflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator.__init__"
+None*
+self~
+=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator*
+args
+Any*
+kwargs
+Any*
+__path__/airflow.providers.amazon.aws.operators.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__6airflow.providers.amazon.aws.operators.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.aws.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.aws.protobuf
new file mode 100644
index 0000000000..e79876bea7
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.aws.protobuf
@@ -0,0 +1,18 @@
+
+airflow.providers.amazon.aws
+EcsRunTaskOperator=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"(airflow.models.baseoperator.BaseOperator*
+__init__Fairflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator.__init__"
+None*
+self~
+=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator*
+args
+Any*
+kwargs
+Any*}
+__path__%airflow.providers.amazon.aws.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__,airflow.providers.amazon.aws.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.protobuf
new file mode 100644
index 0000000000..e52ed00194
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.amazon.protobuf
@@ -0,0 +1,18 @@
+
+airflow.providers.amazon
+EcsRunTaskOperator=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"(airflow.models.baseoperator.BaseOperator*
+__init__Fairflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator.__init__"
+None*
+self~
+=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator*
+args
+Any*
+kwargs
+Any*y
+__path__!airflow.providers.amazon.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__(airflow.providers.amazon.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.http.operators.http.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.http.operators.http.protobuf
new file mode 100644
index 0000000000..684fe91052
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.http.operators.http.protobuf
@@ -0,0 +1,15 @@
+
+%airflow.providers.http.operators.http
+HttpOperator2airflow.providers.http.operators.http.HttpOperator"(airflow.models.baseoperator.BaseOperator*
+__init__;airflow.providers.http.operators.http.HttpOperator.__init__"
+None*r
+selfh
+2airflow.providers.http.operators.http.HttpOperator"2airflow.providers.http.operators.http.HttpOperator*
+args
+Any*
+kwargs
+Any*
+__annotations__5airflow.providers.http.operators.http.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.http.operators.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.http.operators.protobuf
new file mode 100644
index 0000000000..882cd8f5b9
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.http.operators.protobuf
@@ -0,0 +1,18 @@
+
+ airflow.providers.http.operators
+HttpOperator2airflow.providers.http.operators.http.HttpOperator"(airflow.models.baseoperator.BaseOperator*
+__init__;airflow.providers.http.operators.http.HttpOperator.__init__"
+None*r
+selfh
+2airflow.providers.http.operators.http.HttpOperator"2airflow.providers.http.operators.http.HttpOperator*
+args
+Any*
+kwargs
+Any*
+__path__)airflow.providers.http.operators.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__0airflow.providers.http.operators.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.http.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.http.protobuf
new file mode 100644
index 0000000000..be29857b06
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.http.protobuf
@@ -0,0 +1,18 @@
+
+airflow.providers.http
+HttpOperator2airflow.providers.http.operators.http.HttpOperator"(airflow.models.baseoperator.BaseOperator*
+__init__;airflow.providers.http.operators.http.HttpOperator.__init__"
+None*r
+selfh
+2airflow.providers.http.operators.http.HttpOperator"2airflow.providers.http.operators.http.HttpOperator*
+args
+Any*
+kwargs
+Any*w
+__path__airflow.providers.http.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__&airflow.providers.http.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.protobuf
new file mode 100644
index 0000000000..a281df181c
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/airflow.providers.protobuf
@@ -0,0 +1,27 @@
+
+airflow.providers
+EcsRunTaskOperator=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"(airflow.models.baseoperator.BaseOperator*
+__init__Fairflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator.__init__"
+None*
+self~
+=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator"=airflow.providers.amazon.aws.operators.ecs.EcsRunTaskOperator*
+args
+Any*
+kwargs
+Any
+HttpOperator2airflow.providers.http.operators.http.HttpOperator"(airflow.models.baseoperator.BaseOperator*
+__init__;airflow.providers.http.operators.http.HttpOperator.__init__"
+None*r
+selfh
+2airflow.providers.http.operators.http.HttpOperator"2airflow.providers.http.operators.http.HttpOperator*
+args
+Any*
+kwargs
+Any*r
+__path__airflow.providers.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__!airflow.providers.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/assertpy.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/assertpy.protobuf
new file mode 100644
index 0000000000..7749830f0a
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/assertpy.protobuf
@@ -0,0 +1,38 @@
+
+assertpy
+AssertionBuilderassertpy.AssertionBuilder"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+described_as&assertpy.AssertionBuilder.described_as"6
+assertpy.AssertionBuilder"assertpy.AssertionBuilder*@
+self6
+assertpy.AssertionBuilder"assertpy.AssertionBuilder*-
+description
+builtins.str"builtins.str*
+snapshot"assertpy.AssertionBuilder.snapshot"6
+assertpy.AssertionBuilder"assertpy.AssertionBuilder*@
+self6
+assertpy.AssertionBuilder"assertpy.AssertionBuilder*&
+name
+builtins.str"builtins.str*
+is_equal_to%assertpy.AssertionBuilder.is_equal_to"6
+assertpy.AssertionBuilder"assertpy.AssertionBuilder*@
+self6
+assertpy.AssertionBuilder"assertpy.AssertionBuilder*/
+other"
+builtins.object"builtins.object *
+is_not_equal_to)assertpy.AssertionBuilder.is_not_equal_to"6
+assertpy.AssertionBuilder"assertpy.AssertionBuilder*@
+self6
+assertpy.AssertionBuilder"assertpy.AssertionBuilder*-
+other"
+builtins.object"builtins.object
+assert_thatassertpy.assert_that"6
+assertpy.AssertionBuilder"assertpy.AssertionBuilder*-
+val"
+builtins.object"builtins.object *i
+__path__assertpy.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__assertpy.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.client.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.client.protobuf
index 509eb9dae6..2322a28e22 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.client.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.client.protobuf
@@ -1,6 +1,6 @@
 
-
cohere.client3
-Clientcohere.client.Client"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+
cohere.client4
+Clientcohere.client.Client"*SonarPythonAnalyzerFakeStub.CustomStubBase*
 __init__cohere.client.Client.__init__"
 None*6
 self,
@@ -24,10 +24,10 @@
 timeoutJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *:
-httpx_client&
-Union[Any,None]
-Any
+None *X
+httpx_clientD
+Union[httpx.Client,None]
+httpx.Client"httpx.Client
 None *x
 thread_pool_executor\
 ,concurrent.futures.thread.ThreadPoolExecutor",concurrent.futures.thread.ThreadPoolExecutor *G
@@ -286,6 +286,4 @@ MUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]
 __annotations__cohere.client.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict*%
-httpxcohere.client.httpx
-Any
\ No newline at end of file
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.client_v2.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.client_v2.protobuf
index e888ecaf91..deb819adc6 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.client_v2.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.client_v2.protobuf
@@ -1,6 +1,6 @@
 
-cohere.client_v2%
-ClientV2cohere.client_v2.ClientV2"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+cohere.client_v2%
+ClientV2cohere.client_v2.ClientV2"*SonarPythonAnalyzerFakeStub.CustomStubBase*
 __init__"cohere.client_v2.ClientV2.__init__"
 None*@
 self6
@@ -22,10 +22,10 @@
 timeoutJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *:
-httpx_client&
-Union[Any,None]
-Any
+None *X
+httpx_clientD
+Union[httpx.Client,None]
+httpx.Client"httpx.Client
 None *x
 thread_pool_executor\
 ,concurrent.futures.thread.ThreadPoolExecutor",concurrent.futures.thread.ThreadPoolExecutor *G
@@ -213,6 +213,4 @@ max_tokensD
 __annotations__ cohere.client_v2.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict*(
-httpxcohere.client_v2.httpx
-Any
\ No newline at end of file
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.protobuf
index 68a40016c1..9a5d534431 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/cohere.protobuf
@@ -1,6 +1,6 @@
 
-cohere3
-Clientcohere.client.Client"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+cohere4
+Clientcohere.client.Client"*SonarPythonAnalyzerFakeStub.CustomStubBase*
 __init__cohere.client.Client.__init__"
 None*6
 self,
@@ -24,10 +24,10 @@
 timeoutJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *:
-httpx_client&
-Union[Any,None]
-Any
+None *X
+httpx_clientD
+Union[httpx.Client,None]
+httpx.Client"httpx.Client
 None *x
 thread_pool_executor\
 ,concurrent.futures.thread.ThreadPoolExecutor",concurrent.futures.thread.ThreadPoolExecutor *G
@@ -282,8 +282,8 @@ MUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]
 request_options&
 Union[Any,None]
 Any
-None %
-ClientV2cohere.client_v2.ClientV2"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+None %
+ClientV2cohere.client_v2.ClientV2"*SonarPythonAnalyzerFakeStub.CustomStubBase*
 __init__"cohere.client_v2.ClientV2.__init__"
 None*@
 self6
@@ -305,10 +305,10 @@ MUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]
 timeoutJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *:
-httpx_client&
-Union[Any,None]
-Any
+None *X
+httpx_clientD
+Union[httpx.Client,None]
+httpx.Client"httpx.Client
 None *x
 thread_pool_executor\
 ,concurrent.futures.thread.ThreadPoolExecutor",concurrent.futures.thread.ThreadPoolExecutor *G
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/confluent_kafka.aio.consumer.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/confluent_kafka.aio.consumer.protobuf
new file mode 100644
index 0000000000..097b2f7fca
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/confluent_kafka.aio.consumer.protobuf
@@ -0,0 +1,44 @@
+
+confluent_kafka.aio.consumer	
+AIOConsumer(confluent_kafka.aio.consumer.AIOConsumer"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__1confluent_kafka.aio.consumer.AIOConsumer.__init__"
+None*^
+selfT
+(confluent_kafka.aio.consumer.AIOConsumer"(confluent_kafka.aio.consumer.AIOConsumer*E
+config9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict*
+kwargs
+Any*
+	subscribe2confluent_kafka.aio.consumer.AIOConsumer.subscribe"N
+typing.Coroutine[Any,Any,None]
+Any
+Any
+None"typing.Coroutine*^
+selfT
+(confluent_kafka.aio.consumer.AIOConsumer"(confluent_kafka.aio.consumer.AIOConsumer*V
+topicsJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+	on_assign
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *
+	on_revoke
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *
+on_lost
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *
+kwargs
+AnyH*
+__annotations__,confluent_kafka.aio.consumer.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/confluent_kafka.aio.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/confluent_kafka.aio.protobuf
new file mode 100644
index 0000000000..60090a8fe2
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/confluent_kafka.aio.protobuf
@@ -0,0 +1,47 @@
+
+confluent_kafka.aio	
+AIOConsumer(confluent_kafka.aio.consumer.AIOConsumer"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__1confluent_kafka.aio.consumer.AIOConsumer.__init__"
+None*^
+selfT
+(confluent_kafka.aio.consumer.AIOConsumer"(confluent_kafka.aio.consumer.AIOConsumer*E
+config9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict*
+kwargs
+Any*
+	subscribe2confluent_kafka.aio.consumer.AIOConsumer.subscribe"N
+typing.Coroutine[Any,Any,None]
+Any
+Any
+None"typing.Coroutine*^
+selfT
+(confluent_kafka.aio.consumer.AIOConsumer"(confluent_kafka.aio.consumer.AIOConsumer*V
+topicsJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+	on_assign
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *
+	on_revoke
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *
+on_lost
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *
+kwargs
+AnyH*t
+__path__confluent_kafka.aio.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__#confluent_kafka.aio.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/confluent_kafka.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/confluent_kafka.protobuf
new file mode 100644
index 0000000000..456b1d6d6f
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/confluent_kafka.protobuf
@@ -0,0 +1,47 @@
+
+confluent_kafka	
+AIOConsumer(confluent_kafka.aio.consumer.AIOConsumer"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__1confluent_kafka.aio.consumer.AIOConsumer.__init__"
+None*^
+selfT
+(confluent_kafka.aio.consumer.AIOConsumer"(confluent_kafka.aio.consumer.AIOConsumer*E
+config9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict*
+kwargs
+Any*
+	subscribe2confluent_kafka.aio.consumer.AIOConsumer.subscribe"N
+typing.Coroutine[Any,Any,None]
+Any
+Any
+None"typing.Coroutine*^
+selfT
+(confluent_kafka.aio.consumer.AIOConsumer"(confluent_kafka.aio.consumer.AIOConsumer*V
+topicsJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+	on_assign
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *
+	on_revoke
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *
+on_lost
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *
+kwargs
+AnyH*p
+__path__confluent_kafka.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__confluent_kafka.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.config.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.config.protobuf
index 2ee0d25965..21d815f961 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.config.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.config.protobuf
@@ -1,5 +1,5 @@
 
-django.apps.config
+django.apps.config
 	AppConfigdjango.apps.config.AppConfig"builtins.object*
 __init__%django.apps.config.AppConfig.__init__"
 None*F
@@ -8,22 +8,22 @@
 args
 Any*
 kwargs
-Any*
-	get_model&django.apps.config.AppConfig.get_model"
-	Type[Any]
-Any"type*F
+Any*
+	get_model&django.apps.config.AppConfig.get_model"g
+!Type[django.db.models.base.Model]:
+django.db.models.base.Model"django.db.models.base.Model"type*F
 self<
 django.apps.config.AppConfig"django.apps.config.AppConfig*,
 
 model_name
 builtins.str"builtins.str*3
 
require_ready
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 
-get_models'django.apps.config.AppConfig.get_models"K
-typing.Iterator[Type[Any]]
-	Type[Any]
-Any"type"typing.Iterator*F
+get_models'django.apps.config.AppConfig.get_models"
+2typing.Iterator[Type[django.db.models.base.Model]]g
+!Type[django.db.models.base.Model]:
+django.db.models.base.Model"django.db.models.base.Model"type"typing.Iterator*F
 self<
 django.apps.config.AppConfig"django.apps.config.AppConfig*:
 include_auto_created
@@ -33,6 +33,4 @@ get_models'django.apps.config.AppConfig.get_models"K
 __annotations__"django.apps.config.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict**
-Modeldjango.apps.config.Model
-Any
\ No newline at end of file
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.protobuf
index 5430acbc48..cf264df6df 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.protobuf
@@ -1,5 +1,5 @@
 
-django.apps
+django.apps
 	AppConfigdjango.apps.config.AppConfig"builtins.object*
 __init__%django.apps.config.AppConfig.__init__"
 None*F
@@ -8,22 +8,22 @@
 args
 Any*
 kwargs
-Any*
-	get_model&django.apps.config.AppConfig.get_model"
-	Type[Any]
-Any"type*F
+Any*
+	get_model&django.apps.config.AppConfig.get_model"g
+!Type[django.db.models.base.Model]:
+django.db.models.base.Model"django.db.models.base.Model"type*F
 self<
 django.apps.config.AppConfig"django.apps.config.AppConfig*,
 
 model_name
 builtins.str"builtins.str*3
 
require_ready
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 
-get_models'django.apps.config.AppConfig.get_models"K
-typing.Iterator[Type[Any]]
-	Type[Any]
-Any"type"typing.Iterator*F
+get_models'django.apps.config.AppConfig.get_models"
+2typing.Iterator[Type[django.db.models.base.Model]]g
+!Type[django.db.models.base.Model]:
+django.db.models.base.Model"django.db.models.base.Model"type"typing.Iterator*F
 self<
 django.apps.config.AppConfig"django.apps.config.AppConfig*:
 include_auto_created
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.registry.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.registry.protobuf
index d68212d9df..259c8fd736 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.registry.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.apps.registry.protobuf
@@ -1,5 +1,5 @@
 
-django.apps.registry
+django.apps.registry
 Appsdjango.apps.registry.Apps"builtins.object*
 __init__"django.apps.registry.Apps.__init__"
 None*@
@@ -8,21 +8,21 @@
 args
 Any*
 kwargs
-Any*
+Any*
 
-get_models$django.apps.registry.Apps.get_models"G
-builtins.list[Type[Any]]
-	Type[Any]
-Any"type"
builtins.list*@
+get_models$django.apps.registry.Apps.get_models"
+0builtins.list[Type[django.db.models.base.Model]]g
+!Type[django.db.models.base.Model]:
+django.db.models.base.Model"django.db.models.base.Model"type"
builtins.list*@
 self6
 django.apps.registry.Apps"django.apps.registry.Apps*:
 include_auto_created
 
builtins.bool"
builtins.bool *5
 include_swapped
-
builtins.bool"
builtins.bool *
-	get_model#django.apps.registry.Apps.get_model"
-	Type[Any]
-Any"type*@
+
builtins.bool"
builtins.bool *
+	get_model#django.apps.registry.Apps.get_model"g
+!Type[django.db.models.base.Model]:
+django.db.models.base.Model"django.db.models.base.Model"type*@
 self6
 django.apps.registry.Apps"django.apps.registry.Apps*+
 	app_label
@@ -37,8 +37,6 @@ model_nameD
 __annotations__$django.apps.registry.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict*,
-Modeldjango.apps.registry.Model
-Any*Y
+Any"
builtins.dict*Y
 appsdjango.apps.registry.apps6
 django.apps.registry.Apps"django.apps.registry.Apps
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.contrib.auth.middleware.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.contrib.auth.middleware.protobuf
new file mode 100644
index 0000000000..6698b0e6ce
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.contrib.auth.middleware.protobuf
@@ -0,0 +1,25 @@
+
+django.contrib.auth.middleware
+RemoteUserMiddleware3django.contrib.auth.middleware.RemoteUserMiddleware"builtins.object*
+__init__
+parser2
+argparse.ArgumentParser"argparse.ArgumentParser*
+handle.django.core.management.base.BaseCommand.handle"D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*\
+selfR
+'django.core.management.base.BaseCommand"'django.core.management.base.BaseCommand*
+args
+Any*
+options
+Any*
+execute/django.core.management.base.BaseCommand.execute"D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*\
+selfR
+'django.core.management.base.BaseCommand"'django.core.management.base.BaseCommand*
+args
+Any*
+options
+Any*
+
+print_help2django.core.management.base.BaseCommand.print_help"
+None*\
+selfR
+'django.core.management.base.BaseCommand"'django.core.management.base.BaseCommand*+
+	prog_name
+builtins.str"builtins.str*T
+
+subcommandD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*
+get_version3django.core.management.base.BaseCommand.get_version"
+builtins.str"builtins.str*\
+selfR
+'django.core.management.base.BaseCommand"'django.core.management.base.BaseCommandrR
+help,django.core.management.base.BaseCommand.help
+builtins.str"builtins.strr~
+_called_from_command_lineAdjango.core.management.base.BaseCommand._called_from_command_line
+
builtins.bool"
builtins.boolrp
+output_transaction:django.core.management.base.BaseCommand.output_transaction
+
builtins.bool"
builtins.boolr
+requires_migrations_checksBdjango.core.management.base.BaseCommand.requires_migrations_checks
+
builtins.bool"
builtins.boolr
+requires_system_checks>django.core.management.base.BaseCommand.requires_system_checks
+1Union[builtins.str,typing.Sequence[builtins.str]]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequencer
+base_stealth_options
+parser2
+argparse.ArgumentParser"argparse.ArgumentParser*
+handle.django.core.management.base.BaseCommand.handle"D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*\
+selfR
+'django.core.management.base.BaseCommand"'django.core.management.base.BaseCommand*
+args
+Any*
+options
+Any*
+execute/django.core.management.base.BaseCommand.execute"D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*\
+selfR
+'django.core.management.base.BaseCommand"'django.core.management.base.BaseCommand*
+args
+Any*
+options
+Any*
+
+print_help2django.core.management.base.BaseCommand.print_help"
+None*\
+selfR
+'django.core.management.base.BaseCommand"'django.core.management.base.BaseCommand*+
+	prog_name
+builtins.str"builtins.str*T
+
+subcommandD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*
+get_version3django.core.management.base.BaseCommand.get_version"
+builtins.str"builtins.str*\
+selfR
+'django.core.management.base.BaseCommand"'django.core.management.base.BaseCommandrR
+help,django.core.management.base.BaseCommand.help
+builtins.str"builtins.strr~
+_called_from_command_lineAdjango.core.management.base.BaseCommand._called_from_command_line
+
builtins.bool"
builtins.boolrp
+output_transaction:django.core.management.base.BaseCommand.output_transaction
+
builtins.bool"
builtins.boolr
+requires_migrations_checksBdjango.core.management.base.BaseCommand.requires_migrations_checks
+
builtins.bool"
builtins.boolr
+requires_system_checks>django.core.management.base.BaseCommand.requires_system_checks
+1Union[builtins.str,typing.Sequence[builtins.str]]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequencer
+base_stealth_options
+django.http.request.QueryDict"django.http.request.QueryDictrl
+POST$django.http.request.HttpRequest.POST>
+django.http.request.QueryDict"django.http.request.QueryDictrr
+COOKIES'django.http.request.HttpRequest.COOKIES>
+django.http.request.QueryDict"django.http.request.QueryDictrl
+META$django.http.request.HttpRequest.META>
+django.http.request.QueryDict"django.http.request.QueryDictrn
+FILES%django.http.request.HttpRequest.FILES>
+django.http.request.QueryDict"django.http.request.QueryDictrr
+headers'django.http.request.HttpRequest.headers>
+django.http.request.QueryDict"django.http.request.QueryDictX
 HttpResponse!django.http.response.HttpResponse"%django.http.response.HttpResponseBasel
 HttpResponseBadRequest+django.http.response.HttpResponseBadRequest"%django.http.response.HttpResponseBasej
 HttpResponseForbidden*django.http.response.HttpResponseForbidden"%django.http.response.HttpResponseBase`
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.protobuf
index 8f5f3eec83..458c4a0f95 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.protobuf
@@ -12,4 +12,6 @@
 utilsdjango.utils *
 urlsdjango.urls *
 confdjango.conf *
-appsdjango.apps 
\ No newline at end of file
+appsdjango.apps *
+contribdjango.contrib *
+viewsdjango.views 
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.utils.deprecation.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.utils.deprecation.protobuf
new file mode 100644
index 0000000000..bddc77e8cd
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.utils.deprecation.protobuf
@@ -0,0 +1,23 @@
+
+django.utils.deprecation
+MiddlewareMixin(django.utils.deprecation.MiddlewareMixin"builtins.object*
+__init__1django.utils.deprecation.MiddlewareMixin.__init__"
+None*^
+selfT
+(django.utils.deprecation.MiddlewareMixin"(django.utils.deprecation.MiddlewareMixin*]
+get_responseK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+__call__1django.utils.deprecation.MiddlewareMixin.__call__"
+Any*^
+selfT
+(django.utils.deprecation.MiddlewareMixin"(django.utils.deprecation.MiddlewareMixin*
+request
+Anyr
+get_response5django.utils.deprecation.MiddlewareMixin.get_responseK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+__annotations__(django.utils.deprecation.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.utils.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.utils.protobuf
index f324db0031..ef90d1a144 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.utils.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.utils.protobuf
@@ -7,4 +7,5 @@
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
 Any"
builtins.dict*
-htmldjango.utils.html 
\ No newline at end of file
+htmldjango.utils.html *)
+deprecationdjango.utils.deprecation 
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.decorators.http.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.decorators.http.protobuf
new file mode 100644
index 0000000000..ef927ec0d3
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.decorators.http.protobuf
@@ -0,0 +1,30 @@
+
+django.views.decorators.http
+require_http_methods1django.views.decorators.http.require_http_methods"K
+CallableType[builtins.function]&
+builtins.function"builtins.function*c
+request_method_listJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.listh
+require_GET(django.views.decorators.http.require_GET"
+Any*
+args
+Any*
+kwargs
+Anyj
+require_POST)django.views.decorators.http.require_POST"
+Any*
+args
+Any*
+kwargs
+Anyj
+require_safe)django.views.decorators.http.require_safe"
+Any*
+args
+Any*
+kwargs
+Any*
+__annotations__,django.views.decorators.http.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.decorators.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.decorators.protobuf
new file mode 100644
index 0000000000..abf7e4aec6
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.decorators.protobuf
@@ -0,0 +1,10 @@
+
+django.views.decorators*x
+__path__ django.views.decorators.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__'django.views.decorators.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*&
+httpdjango.views.decorators.http 
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.generic.base.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.generic.base.protobuf
new file mode 100644
index 0000000000..ce7ce7f9d6
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.generic.base.protobuf
@@ -0,0 +1,218 @@
+
+django.views.generic.base
+ContextMixin&django.views.generic.base.ContextMixin"builtins.object*
+get_context_data7django.views.generic.base.ContextMixin.get_context_data"W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*Z
+selfP
+&django.views.generic.base.ContextMixin"&django.views.generic.base.ContextMixin*
+kwargs
+Anyr
+
extra_context4django.views.generic.base.ContextMixin.extra_context
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None
+Viewdjango.views.generic.base.View"builtins.object*
+setup$django.views.generic.base.View.setup"
+None*J
+self@
+django.views.generic.base.View"django.views.generic.base.View*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+dispatch'django.views.generic.base.View.dispatch"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*J
+self@
+django.views.generic.base.View"django.views.generic.base.View*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+http_method_not_allowed6django.views.generic.base.View.http_method_not_allowed"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*J
+self@
+django.views.generic.base.View"django.views.generic.base.View*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+options&django.views.generic.base.View.options"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*J
+self@
+django.views.generic.base.View"django.views.generic.base.View*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+as_view&django.views.generic.base.View.as_view"K
+CallableType[builtins.function]&
+builtins.function"builtins.function*y
+clsp
+$Type[django.views.generic.base.View]@
+django.views.generic.base.View"django.views.generic.base.View"type*
+
+initkwargs
+Any0:builtins.classmethodpr
+http_method_names0django.views.generic.base.View.http_method_namesJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.listru
+request&django.views.generic.base.View.requestB
+django.http.request.HttpRequest"django.http.request.HttpRequestr[
+args#django.views.generic.base.View.args.
+builtins.tuple[Any]
+Any"builtins.tuplerj
+kwargs%django.views.generic.base.View.kwargs9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+TemplateResponseMixin/django.views.generic.base.TemplateResponseMixin"builtins.object*
+render_to_responseBdjango.views.generic.base.TemplateResponseMixin.render_to_response"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*l
+selfb
+/django.views.generic.base.TemplateResponseMixin"/django.views.generic.base.TemplateResponseMixin*d
+contextW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*
+response_kwargs
+Any*
+get_template_namesBdjango.views.generic.base.TemplateResponseMixin.get_template_names"J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*l
+selfb
+/django.views.generic.base.TemplateResponseMixin"/django.views.generic.base.TemplateResponseMixinr
+
template_name=django.views.generic.base.TemplateResponseMixin.template_nameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Noner
+template_engine?django.views.generic.base.TemplateResponseMixin.template_engineD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Noner
+response_class>django.views.generic.base.TemplateResponseMixin.response_classy
+'Type[django.http.response.HttpResponse]F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse"typer
+content_typedjango.views.generic.dates.BaseDateListView.get_dated_queryset"
+Any*d
+selfZ
++django.views.generic.dates.BaseDateListView"+django.views.generic.dates.BaseDateListView*
+lookup
+Any*
+get_date_list_period@django.views.generic.dates.BaseDateListView.get_date_list_period"
+builtins.str"builtins.str*d
+selfZ
++django.views.generic.dates.BaseDateListView"+django.views.generic.dates.BaseDateListView*
+
get_date_list9django.views.generic.dates.BaseDateListView.get_date_list"
+Any*d
+selfZ
++django.views.generic.dates.BaseDateListView"+django.views.generic.dates.BaseDateListView*
+queryset
+Any*U
+	date_typeD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+ordering
+builtins.str"builtins.str rf
+allow_empty7django.views.generic.dates.BaseDateListView.allow_empty
+
builtins.bool"
builtins.boolrn
+date_list_perioddjango.views.generic.dates.BaseYearArchiveView.get_dated_items"
+.Tuple[Any,Any,builtins.dict[builtins.str,Any]]
+Any
+AnyW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*j
+self`
+.django.views.generic.dates.BaseYearArchiveView".django.views.generic.dates.BaseYearArchiveView*
+get_make_object_listCdjango.views.generic.dates.BaseYearArchiveView.get_make_object_list"
+
builtins.bool"
builtins.bool*j
+self`
+.django.views.generic.dates.BaseYearArchiveView".django.views.generic.dates.BaseYearArchiveViewrq
+date_list_period?django.views.generic.dates.BaseYearArchiveView.date_list_period
+builtins.str"builtins.strrs
+make_object_list?django.views.generic.dates.BaseYearArchiveView.make_object_list
+
builtins.bool"
builtins.bool
+YearArchiveView*django.views.generic.dates.YearArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin".django.views.generic.dates.BaseYearArchiveViewru
+template_name_suffix?django.views.generic.dates.YearArchiveView.template_name_suffix
+builtins.str"builtins.str
+BaseMonthArchiveView/django.views.generic.dates.BaseMonthArchiveView"$django.views.generic.dates.YearMixin"%django.views.generic.dates.MonthMixin"+django.views.generic.dates.BaseDateListView*
+get_dated_items?django.views.generic.dates.BaseMonthArchiveView.get_dated_items"
+.Tuple[Any,Any,builtins.dict[builtins.str,Any]]
+Any
+AnyW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*l
+selfb
+/django.views.generic.dates.BaseMonthArchiveView"/django.views.generic.dates.BaseMonthArchiveViewrr
+date_list_period@django.views.generic.dates.BaseMonthArchiveView.date_list_period
+builtins.str"builtins.str
+MonthArchiveView+django.views.generic.dates.MonthArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin"/django.views.generic.dates.BaseMonthArchiveViewrv
+template_name_suffix@django.views.generic.dates.MonthArchiveView.template_name_suffix
+builtins.str"builtins.str
+BaseWeekArchiveView.django.views.generic.dates.BaseWeekArchiveView"$django.views.generic.dates.YearMixin"$django.views.generic.dates.WeekMixin"+django.views.generic.dates.BaseDateListView*
+get_dated_items>django.views.generic.dates.BaseWeekArchiveView.get_dated_items"
+.Tuple[Any,Any,builtins.dict[builtins.str,Any]]
+Any
+AnyW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*j
+self`
+.django.views.generic.dates.BaseWeekArchiveView".django.views.generic.dates.BaseWeekArchiveView
+WeekArchiveView*django.views.generic.dates.WeekArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin".django.views.generic.dates.BaseWeekArchiveViewru
+template_name_suffix?django.views.generic.dates.WeekArchiveView.template_name_suffix
+builtins.str"builtins.str
+BaseDayArchiveView-django.views.generic.dates.BaseDayArchiveView"$django.views.generic.dates.YearMixin"%django.views.generic.dates.MonthMixin"#django.views.generic.dates.DayMixin"+django.views.generic.dates.BaseDateListView*
+get_dated_items=django.views.generic.dates.BaseDayArchiveView.get_dated_items"
+.Tuple[Any,Any,builtins.dict[builtins.str,Any]]
+Any
+AnyW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*h
+self^
+-django.views.generic.dates.BaseDayArchiveView"-django.views.generic.dates.BaseDayArchiveView
+DayArchiveView)django.views.generic.dates.DayArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin"-django.views.generic.dates.BaseDayArchiveViewrt
+template_name_suffix>django.views.generic.dates.DayArchiveView.template_name_suffix
+builtins.str"builtins.str
+BaseTodayArchiveView/django.views.generic.dates.BaseTodayArchiveView"-django.views.generic.dates.BaseDayArchiveView*
+get_dated_items?django.views.generic.dates.BaseTodayArchiveView.get_dated_items"
+.Tuple[Any,Any,builtins.dict[builtins.str,Any]]
+Any
+AnyW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*l
+selfb
+/django.views.generic.dates.BaseTodayArchiveView"/django.views.generic.dates.BaseTodayArchiveView
+TodayArchiveView+django.views.generic.dates.TodayArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin"/django.views.generic.dates.BaseTodayArchiveViewrv
+template_name_suffix@django.views.generic.dates.TodayArchiveView.template_name_suffix
+builtins.str"builtins.str
+BaseDateDetailView-django.views.generic.dates.BaseDateDetailView"$django.views.generic.dates.YearMixin"%django.views.generic.dates.MonthMixin"#django.views.generic.dates.DayMixin"$django.views.generic.dates.DateMixin"*django.views.generic.detail.BaseDetailView*
+
+get_object8django.views.generic.dates.BaseDateDetailView.get_object"
+Any*h
+self^
+-django.views.generic.dates.BaseDateDetailView"-django.views.generic.dates.BaseDateDetailView*6
+queryset&
+Union[Any,None]
+Any
+None 
+DateDetailView)django.views.generic.dates.DateDetailView"=django.views.generic.detail.SingleObjectTemplateResponseMixin"-django.views.generic.dates.BaseDateDetailViewrt
+template_name_suffix>django.views.generic.dates.DateDetailView.template_name_suffix
+builtins.str"builtins.str*
+__annotations__*django.views.generic.dates.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*:
+	Paginator$django.views.generic.dates.Paginator
+Any
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.generic.detail.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.generic.detail.protobuf
new file mode 100644
index 0000000000..f4227568ba
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.generic.detail.protobuf
@@ -0,0 +1,89 @@
+
+django.views.generic.detail
+SingleObjectMixin-django.views.generic.detail.SingleObjectMixin"&django.views.generic.base.ContextMixin*
+
+get_object8django.views.generic.detail.SingleObjectMixin.get_object"
+Any*h
+self^
+-django.views.generic.detail.SingleObjectMixin"-django.views.generic.detail.SingleObjectMixin*6
+queryset&
+Union[Any,None]
+Any
+None *
+get_queryset:django.views.generic.detail.SingleObjectMixin.get_queryset"
+Any*h
+self^
+-django.views.generic.detail.SingleObjectMixin"-django.views.generic.detail.SingleObjectMixin*
+get_slug_fielddjango.views.generic.detail.SingleObjectMixin.get_context_data"W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*h
+self^
+-django.views.generic.detail.SingleObjectMixin"-django.views.generic.detail.SingleObjectMixin*
+kwargs
+Anyr
+model3django.views.generic.detail.SingleObjectMixin.model
+-Union[Type[django.db.models.base.Model],None]g
+!Type[django.db.models.base.Model]:
+django.db.models.base.Model"django.db.models.base.Model"type
+Nonerj
+queryset6django.views.generic.detail.SingleObjectMixin.queryset&
+Union[Any,None]
+Any
+Nonerd
+
+slug_field8django.views.generic.detail.SingleObjectMixin.slug_field
+builtins.str"builtins.strr
+context_object_nameAdjango.views.generic.detail.SingleObjectMixin.context_object_nameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerl
+slug_url_kwargdjango.views.generic.list.MultipleObjectMixin.get_context_data"W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*h
+self^
+-django.views.generic.list.MultipleObjectMixin"-django.views.generic.list.MultipleObjectMixin*9
+object_list&
+Union[Any,None]
+Any
+None *
+kwargs
+Anyrh
+allow_empty9django.views.generic.list.MultipleObjectMixin.allow_empty
+
builtins.bool"
builtins.boolrj
+queryset6django.views.generic.list.MultipleObjectMixin.queryset&
+Union[Any,None]
+Any
+Noner
+model3django.views.generic.list.MultipleObjectMixin.model
+-Union[Type[django.db.models.base.Model],None]g
+!Type[django.db.models.base.Model]:
+django.db.models.base.Model"django.db.models.base.Model"type
+Noner
+paginate_by9django.views.generic.list.MultipleObjectMixin.paginate_byD
+Union[builtins.int,None]
+builtins.int"builtins.int
+Nonerp
+paginate_orphans>django.views.generic.list.MultipleObjectMixin.paginate_orphans
+builtins.int"builtins.intr
+context_object_nameAdjango.views.generic.list.MultipleObjectMixin.context_object_nameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonern
+paginator_class=django.views.generic.list.MultipleObjectMixin.paginator_class
+	Type[Any]
+Any"typerd
+
+page_kwarg8django.views.generic.list.MultipleObjectMixin.page_kwarg
+builtins.str"builtins.strrj
+ordering6django.views.generic.list.MultipleObjectMixin.ordering&
+Union[Any,None]
+Any
+NonerQ
+object_list9django.views.generic.list.MultipleObjectMixin.object_list
+Any
+BaseListView&django.views.generic.list.BaseListView"-django.views.generic.list.MultipleObjectMixin"django.views.generic.base.View*
+get*django.views.generic.list.BaseListView.get"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*Z
+selfP
+&django.views.generic.list.BaseListView"&django.views.generic.list.BaseListView*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any
+#MultipleObjectTemplateResponseMixin=django.views.generic.list.MultipleObjectTemplateResponseMixin"/django.views.generic.base.TemplateResponseMixin*
+get_template_namesPdjango.views.generic.list.MultipleObjectTemplateResponseMixin.get_template_names"J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+self~
+=django.views.generic.list.MultipleObjectTemplateResponseMixin"=django.views.generic.list.MultipleObjectTemplateResponseMixinr
+template_name_suffixRdjango.views.generic.list.MultipleObjectTemplateResponseMixin.template_name_suffix
+builtins.str"builtins.str
+ListView"django.views.generic.list.ListView"=django.views.generic.list.MultipleObjectTemplateResponseMixin"&django.views.generic.list.BaseListView*
+__annotations__)django.views.generic.list.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*9
+	Paginator#django.views.generic.list.Paginator
+Any
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.generic.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.generic.protobuf
new file mode 100644
index 0000000000..f2067d188d
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.generic.protobuf
@@ -0,0 +1,214 @@
+
+django.views.generic
+RedirectView&django.views.generic.base.RedirectView"django.views.generic.base.View*
+get_redirect_url7django.views.generic.base.RedirectView.get_redirect_url"D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*Z
+selfP
+&django.views.generic.base.RedirectView"&django.views.generic.base.RedirectView*
+args
+Any*
+kwargs
+Any*
+get*django.views.generic.base.RedirectView.get"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*Z
+selfP
+&django.views.generic.base.RedirectView"&django.views.generic.base.RedirectView*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+head+django.views.generic.base.RedirectView.head"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*Z
+selfP
+&django.views.generic.base.RedirectView"&django.views.generic.base.RedirectView*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+post+django.views.generic.base.RedirectView.post"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*Z
+selfP
+&django.views.generic.base.RedirectView"&django.views.generic.base.RedirectView*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+options.django.views.generic.base.RedirectView.options"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*Z
+selfP
+&django.views.generic.base.RedirectView"&django.views.generic.base.RedirectView*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+delete-django.views.generic.base.RedirectView.delete"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*Z
+selfP
+&django.views.generic.base.RedirectView"&django.views.generic.base.RedirectView*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+put*django.views.generic.base.RedirectView.put"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*Z
+selfP
+&django.views.generic.base.RedirectView"&django.views.generic.base.RedirectView*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+patch,django.views.generic.base.RedirectView.patch"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*Z
+selfP
+&django.views.generic.base.RedirectView"&django.views.generic.base.RedirectView*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Anyr]
+	permanent0django.views.generic.base.RedirectView.permanent
+
builtins.bool"
builtins.boolrw
+url*django.views.generic.base.RedirectView.urlD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Noner
+pattern_name3django.views.generic.base.RedirectView.pattern_nameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerc
+query_string3django.views.generic.base.RedirectView.query_string
+
builtins.bool"
builtins.bool
+TemplateView&django.views.generic.base.TemplateView"/django.views.generic.base.TemplateResponseMixin"&django.views.generic.base.ContextMixin"django.views.generic.base.View*
+get*django.views.generic.base.TemplateView.get"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*Z
+selfP
+&django.views.generic.base.TemplateView"&django.views.generic.base.TemplateView*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any
+Viewdjango.views.generic.base.View"builtins.object*
+setup$django.views.generic.base.View.setup"
+None*J
+self@
+django.views.generic.base.View"django.views.generic.base.View*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+dispatch'django.views.generic.base.View.dispatch"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*J
+self@
+django.views.generic.base.View"django.views.generic.base.View*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+http_method_not_allowed6django.views.generic.base.View.http_method_not_allowed"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*J
+self@
+django.views.generic.base.View"django.views.generic.base.View*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+options&django.views.generic.base.View.options"F
+!django.http.response.HttpResponse"!django.http.response.HttpResponse*J
+self@
+django.views.generic.base.View"django.views.generic.base.View*O
+requestB
+django.http.request.HttpRequest"django.http.request.HttpRequest*
+args
+Any*
+kwargs
+Any*
+as_view&django.views.generic.base.View.as_view"K
+CallableType[builtins.function]&
+builtins.function"builtins.function*y
+clsp
+$Type[django.views.generic.base.View]@
+django.views.generic.base.View"django.views.generic.base.View"type*
+
+initkwargs
+Any0:builtins.classmethodpr
+http_method_names0django.views.generic.base.View.http_method_namesJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.listru
+request&django.views.generic.base.View.requestB
+django.http.request.HttpRequest"django.http.request.HttpRequestr[
+args#django.views.generic.base.View.args.
+builtins.tuple[Any]
+Any"builtins.tuplerj
+kwargs%django.views.generic.base.View.kwargs9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+ArchiveIndexView+django.views.generic.dates.ArchiveIndexView"=django.views.generic.list.MultipleObjectTemplateResponseMixin"/django.views.generic.dates.BaseArchiveIndexViewrv
+template_name_suffix@django.views.generic.dates.ArchiveIndexView.template_name_suffix
+builtins.str"builtins.str
+DateDetailView)django.views.generic.dates.DateDetailView"=django.views.generic.detail.SingleObjectTemplateResponseMixin"-django.views.generic.dates.BaseDateDetailViewrt
+template_name_suffix>django.views.generic.dates.DateDetailView.template_name_suffix
+builtins.str"builtins.str
+DayArchiveView)django.views.generic.dates.DayArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin"-django.views.generic.dates.BaseDayArchiveViewrt
+template_name_suffix>django.views.generic.dates.DayArchiveView.template_name_suffix
+builtins.str"builtins.str
+MonthArchiveView+django.views.generic.dates.MonthArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin"/django.views.generic.dates.BaseMonthArchiveViewrv
+template_name_suffix@django.views.generic.dates.MonthArchiveView.template_name_suffix
+builtins.str"builtins.str
+TodayArchiveView+django.views.generic.dates.TodayArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin"/django.views.generic.dates.BaseTodayArchiveViewrv
+template_name_suffix@django.views.generic.dates.TodayArchiveView.template_name_suffix
+builtins.str"builtins.str
+WeekArchiveView*django.views.generic.dates.WeekArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin".django.views.generic.dates.BaseWeekArchiveViewru
+template_name_suffix?django.views.generic.dates.WeekArchiveView.template_name_suffix
+builtins.str"builtins.str
+YearArchiveView*django.views.generic.dates.YearArchiveView"=django.views.generic.list.MultipleObjectTemplateResponseMixin".django.views.generic.dates.BaseYearArchiveViewru
+template_name_suffix?django.views.generic.dates.YearArchiveView.template_name_suffix
+builtins.str"builtins.str
+
+DetailView&django.views.generic.detail.DetailView"=django.views.generic.detail.SingleObjectTemplateResponseMixin"*django.views.generic.detail.BaseDetailView
+
+CreateView$django.views.generic.edit.CreateView"=django.views.generic.detail.SingleObjectTemplateResponseMixin"(django.views.generic.edit.BaseCreateViewro
+template_name_suffix9django.views.generic.edit.CreateView.template_name_suffix
+builtins.str"builtins.str
+
+DeleteView$django.views.generic.edit.DeleteView"=django.views.generic.detail.SingleObjectTemplateResponseMixin"(django.views.generic.edit.BaseDeleteViewro
+template_name_suffix9django.views.generic.edit.DeleteView.template_name_suffix
+builtins.str"builtins.str
+FormView"django.views.generic.edit.FormView"/django.views.generic.base.TemplateResponseMixin"&django.views.generic.edit.BaseFormView
+
+UpdateView$django.views.generic.edit.UpdateView"=django.views.generic.detail.SingleObjectTemplateResponseMixin"(django.views.generic.edit.BaseUpdateViewro
+template_name_suffix9django.views.generic.edit.UpdateView.template_name_suffix
+builtins.str"builtins.str
+ListView"django.views.generic.list.ListView"=django.views.generic.list.MultipleObjectTemplateResponseMixin"&django.views.generic.list.BaseListViewM
+GenericViewError%django.views.generic.GenericViewError"builtins.Exception*u
+__path__django.views.generic.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__$django.views.generic.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*#
+basedjango.views.generic.base 
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.protobuf
new file mode 100644
index 0000000000..b5368ffa23
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/django.views.protobuf
@@ -0,0 +1,12 @@
+
+django.views*m
+__path__django.views.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__django.views.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*'
+
+decoratorsdjango.views.decorators *!
+genericdjango.views.generic 
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/httpx.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/httpx.protobuf
new file mode 100644
index 0000000000..94e2e9205f
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/httpx.protobuf
@@ -0,0 +1,35 @@
+
+httpx
+AsyncClienthttpx.AsyncClient"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__httpx.AsyncClient.__init__"
+None*0
+self&
+httpx.AsyncClient"httpx.AsyncClient*
+event_hooks
+Jbuiltins.dict[builtins.str,builtins.list[CallableType[builtins.function]]]
+builtins.str"builtins.str
+.builtins.list[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"
builtins.list"
builtins.dict *
+kwargs
+Any
+Clienthttpx.Client"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__httpx.Client.__init__"
+None*&
+self
+httpx.Client"httpx.Client*
+event_hooks
+Jbuiltins.dict[builtins.str,builtins.list[CallableType[builtins.function]]]
+builtins.str"builtins.str
+.builtins.list[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"
builtins.list"
builtins.dict *
+kwargs
+Any*f
+__path__httpx.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__httpx.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/marimo.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/marimo.protobuf
new file mode 100644
index 0000000000..5a4252c35f
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/marimo.protobuf
@@ -0,0 +1,48 @@
+
+marimo
+App
+marimo.App"*SonarPythonAnalyzerFakeStub.CustomStubBase*u
+__init__marimo.App.__init__"
+None*"
+self
+
+marimo.App"
+marimo.App*
+args
+Any*
+kwargs
+Any*l
+cellmarimo.App.cell"
+Any*"
+self
+
+marimo.App"
+marimo.App*
+args
+Any*
+kwargs
+Any*t
+functionmarimo.App.function"
+Any*"
+self
+
+marimo.App"
+marimo.App*
+args
+Any*
+kwargs
+AnyX
+sql
+marimo.sql"
+Any*'
+query
+builtins.str"builtins.str*
+kwargs
+Any*g
+__path__marimo.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__marimo.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pg.connection.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pg.connection.protobuf
new file mode 100644
index 0000000000..1ff9834e65
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pg.connection.protobuf
@@ -0,0 +1,48 @@
+
+
pg.connection
+
+Connectionpg.connection.Connection"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__!pg.connection.Connection.__init__"
+None*>
+self4
+pg.connection.Connection"pg.connection.Connection*R
+dbnameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+hostD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *(
+port
+builtins.int"builtins.int *O
+optD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+userD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *R
+passwdD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+nowait
+
builtins.bool"
builtins.bool *
+querypg.connection.Connection.query"
+None*>
+self4
+pg.connection.Connection"pg.connection.Connection*)
+command
+builtins.str"builtins.str*
+args
+Any*q
+closepg.connection.Connection.close"
+None*>
+self4
+pg.connection.Connection"pg.connection.Connection*
+__annotations__pg.connection.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pg.db.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pg.db.protobuf
new file mode 100644
index 0000000000..84272ac7f4
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pg.db.protobuf
@@ -0,0 +1,47 @@
+
+pg.db
+DBpg.db.DB"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__pg.db.DB.__init__"
+None*
+self
+pg.db.DB"pg.db.DB*R
+dbnameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+hostD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *(
+port
+builtins.int"builtins.int *O
+optD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+userD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *R
+passwdD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+nowait
+
builtins.bool"
builtins.bool *
+querypg.db.DB.query"
+None*
+self
+pg.db.DB"pg.db.DB*)
+command
+builtins.str"builtins.str*
+args
+Any*A
+closepg.db.DB.close"
+None*
+self
+pg.db.DB"pg.db.DB*
+__annotations__pg.db.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pg.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pg.protobuf
new file mode 100644
index 0000000000..15762419ef
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pg.protobuf
@@ -0,0 +1,119 @@
+
+pg
+
+Connectionpg.connection.Connection"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__!pg.connection.Connection.__init__"
+None*>
+self4
+pg.connection.Connection"pg.connection.Connection*R
+dbnameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+hostD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *(
+port
+builtins.int"builtins.int *O
+optD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+userD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *R
+passwdD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+nowait
+
builtins.bool"
builtins.bool *
+querypg.connection.Connection.query"
+None*>
+self4
+pg.connection.Connection"pg.connection.Connection*)
+command
+builtins.str"builtins.str*
+args
+Any*q
+closepg.connection.Connection.close"
+None*>
+self4
+pg.connection.Connection"pg.connection.Connection
+DBpg.db.DB"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__pg.db.DB.__init__"
+None*
+self
+pg.db.DB"pg.db.DB*R
+dbnameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+hostD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *(
+port
+builtins.int"builtins.int *O
+optD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+userD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *R
+passwdD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+nowait
+
builtins.bool"
builtins.bool *
+querypg.db.DB.query"
+None*
+self
+pg.db.DB"pg.db.DB*)
+command
+builtins.str"builtins.str*
+args
+Any*A
+closepg.db.DB.close"
+None*
+self
+pg.db.DB"pg.db.DB
+connect
+pg.connect"4
+pg.connection.Connection"pg.connection.Connection*R
+dbnameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+hostD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *(
+port
+builtins.int"builtins.int *O
+optD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *P
+userD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *R
+passwdD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+nowait
+
builtins.bool"
builtins.bool *c
+__path__pg.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*~
+__annotations__pg.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/portkey_ai.api_resources.client.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/portkey_ai.api_resources.client.protobuf
index 7c59600ec4..d55b13e070 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/portkey_ai.api_resources.client.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/portkey_ai.api_resources.client.protobuf
@@ -1,6 +1,6 @@
 
-portkey_ai.api_resources.client7
-Portkey'portkey_ai.api_resources.client.Portkey"*SonarPythonAnalyzerFakeStub.CustomStubBase*#
+portkey_ai.api_resources.client7
+Portkey'portkey_ai.api_resources.client.Portkey"*SonarPythonAnalyzerFakeStub.CustomStubBase*#
 __init__0portkey_ai.api_resources.client.Portkey.__init__"
 None*\
 selfR
@@ -129,10 +129,10 @@ aws_regionD
 huggingface_base_urlD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *9
-http_client&
-Union[Any,None]
-Any
+None *W
+http_clientD
+Union[httpx.Client,None]
+httpx.Client"httpx.Client
 None *[
 request_timeoutD
 Union[builtins.int,None]
@@ -256,8 +256,8 @@ guardrails2portkey_ai.api_resources.client.Portkey.guardrails
 videos.portkey_ai.api_resources.client.Portkey.videos
 Anyr=
 beta,portkey_ai.api_resources.client.Portkey.beta
-Any8
-AsyncPortkey,portkey_ai.api_resources.client.AsyncPortkey"*SonarPythonAnalyzerFakeStub.CustomStubBase*#
+Any9
+AsyncPortkey,portkey_ai.api_resources.client.AsyncPortkey"*SonarPythonAnalyzerFakeStub.CustomStubBase*#
 __init__5portkey_ai.api_resources.client.AsyncPortkey.__init__"
 None*f
 self\
@@ -386,10 +386,10 @@ aws_regionD
 huggingface_base_urlD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *9
-http_client&
-Union[Any,None]
-Any
+None *f
+http_clientS
+Union[httpx.AsyncClient,None]&
+httpx.AsyncClient"httpx.AsyncClient
 None *[
 request_timeoutD
 Union[builtins.int,None]
@@ -521,6 +521,4 @@ guardrails7portkey_ai.api_resources.client.AsyncPortkey.guardrails
 	APIClient)portkey_ai.api_resources.client.APIClient
 Any*I
 AsyncAPIClient.portkey_ai.api_resources.client.AsyncAPIClient
-Any*7
-httpx%portkey_ai.api_resources.client.httpx
 Any
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/portkey_ai.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/portkey_ai.protobuf
index 04bd70b490..1179c20621 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/portkey_ai.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/portkey_ai.protobuf
@@ -1,7 +1,7 @@
 
 
-portkey_ai7
-Portkey'portkey_ai.api_resources.client.Portkey"*SonarPythonAnalyzerFakeStub.CustomStubBase*#
+portkey_ai7
+Portkey'portkey_ai.api_resources.client.Portkey"*SonarPythonAnalyzerFakeStub.CustomStubBase*#
 __init__0portkey_ai.api_resources.client.Portkey.__init__"
 None*\
 selfR
@@ -130,10 +130,10 @@ aws_regionD
 huggingface_base_urlD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *9
-http_client&
-Union[Any,None]
-Any
+None *W
+http_clientD
+Union[httpx.Client,None]
+httpx.Client"httpx.Client
 None *[
 request_timeoutD
 Union[builtins.int,None]
@@ -257,8 +257,8 @@ guardrails2portkey_ai.api_resources.client.Portkey.guardrails
 videos.portkey_ai.api_resources.client.Portkey.videos
 Anyr=
 beta,portkey_ai.api_resources.client.Portkey.beta
-Any8
-AsyncPortkey,portkey_ai.api_resources.client.AsyncPortkey"*SonarPythonAnalyzerFakeStub.CustomStubBase*#
+Any9
+AsyncPortkey,portkey_ai.api_resources.client.AsyncPortkey"*SonarPythonAnalyzerFakeStub.CustomStubBase*#
 __init__5portkey_ai.api_resources.client.AsyncPortkey.__init__"
 None*f
 self\
@@ -387,10 +387,10 @@ aws_regionD
 huggingface_base_urlD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *9
-http_client&
-Union[Any,None]
-Any
+None *f
+http_clientS
+Union[httpx.AsyncClient,None]&
+httpx.AsyncClient"httpx.AsyncClient
 None *[
 request_timeoutD
 Union[builtins.int,None]
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.config.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.config.protobuf
new file mode 100644
index 0000000000..ac8859f1f6
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.config.protobuf
@@ -0,0 +1,14 @@
+
+pydantic.config
+
+ConfigDictpydantic.config.ConfigDict"builtins.object*
+__init__#pydantic.config.ConfigDict.__init__"
+None*B
+self8
+pydantic.config.ConfigDict"pydantic.config.ConfigDict*
+kwargs
+Any*
+__annotations__pydantic.config.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.fields.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.fields.protobuf
new file mode 100644
index 0000000000..c11f4a523b
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.fields.protobuf
@@ -0,0 +1,22 @@
+
+pydantic.fields7
+	FieldInfopydantic.fields.FieldInfo"builtins.object
+PrivateAttrpydantic.fields.PrivateAttr"builtins.object*
+__init__$pydantic.fields.PrivateAttr.__init__"
+None*D
+self:
+pydantic.fields.PrivateAttr"pydantic.fields.PrivateAttr*
+default
+Any *
+kwargs
+AnyT
+Fieldpydantic.fields.Field"
+Any*
+default
+Any *
+kwargs
+Any*
+__annotations__pydantic.fields.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.functional_validators.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.functional_validators.protobuf
new file mode 100644
index 0000000000..f1d3f28a5c
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.functional_validators.protobuf
@@ -0,0 +1,80 @@
+
+pydantic.functional_validators
+AfterValidator-pydantic.functional_validators.AfterValidator"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__6pydantic.functional_validators.AfterValidator.__init__"
+None*h
+self^
+-pydantic.functional_validators.AfterValidator"-pydantic.functional_validators.AfterValidator*U
+funcK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+BeforeValidator.pydantic.functional_validators.BeforeValidator"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__7pydantic.functional_validators.BeforeValidator.__init__"
+None*j
+self`
+.pydantic.functional_validators.BeforeValidator".pydantic.functional_validators.BeforeValidator*U
+funcK
+CallableType[builtins.function]&
+builtins.function"builtins.function*%
+json_schema_input_type
+Any 
+PlainValidator-pydantic.functional_validators.PlainValidator"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__6pydantic.functional_validators.PlainValidator.__init__"
+None*h
+self^
+-pydantic.functional_validators.PlainValidator"-pydantic.functional_validators.PlainValidator*U
+funcK
+CallableType[builtins.function]&
+builtins.function"builtins.function*%
+json_schema_input_type
+Any 
+
WrapValidator,pydantic.functional_validators.WrapValidator"*SonarPythonAnalyzerFakeStub.CustomStubBase*
+__init__5pydantic.functional_validators.WrapValidator.__init__"
+None*f
+self\
+,pydantic.functional_validators.WrapValidator",pydantic.functional_validators.WrapValidator*U
+funcK
+CallableType[builtins.function]&
+builtins.function"builtins.function*%
+json_schema_input_type
+Any c
+
+InstanceOf)pydantic.functional_validators.InstanceOf"*SonarPythonAnalyzerFakeStub.CustomStubBasek
+SkipValidation-pydantic.functional_validators.SkipValidation"*SonarPythonAnalyzerFakeStub.CustomStubBase
+field_validator.pydantic.functional_validators.field_validator"K
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+builtins.str"builtins.str*(
+fields
+builtins.str"builtins.str*
+mode
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"2pydantic.functional_validators.FieldValidatorModes *[
+check_fieldsG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *%
+json_schema_input_type
+Any 
+model_validator.pydantic.functional_validators.model_validator"
+Any*
+mode
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+__annotations__.pydantic.functional_validators.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.main.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.main.protobuf
new file mode 100644
index 0000000000..50aecea204
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.main.protobuf
@@ -0,0 +1,7 @@
+
+
pydantic.main5
+	BaseModelpydantic.main.BaseModel"builtins.object*
+__annotations__pydantic.main.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.networks.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.networks.protobuf
new file mode 100644
index 0000000000..d42134fe69
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.networks.protobuf
@@ -0,0 +1,104 @@
+
+pydantic.networks
+AnyUrlpydantic.networks.AnyUrl"builtins.object*
+unicode_string'pydantic.networks.AnyUrl.unicode_string"
+builtins.str"builtins.str*>
+self4
+pydantic.networks.AnyUrl"pydantic.networks.AnyUrl*
+unicode_host%pydantic.networks.AnyUrl.unicode_host"
+builtins.str"builtins.str*>
+self4
+pydantic.networks.AnyUrl"pydantic.networks.AnyUrl*
+query_params%pydantic.networks.AnyUrl.query_params",
+builtins.list[Any]
+Any"
builtins.list*>
+self4
+pydantic.networks.AnyUrl"pydantic.networks.AnyUrl*
+encoded_string'pydantic.networks.AnyUrl.encoded_string"
+builtins.str"builtins.str*>
+self4
+pydantic.networks.AnyUrl"pydantic.networks.AnyUrlrG
+schemepydantic.networks.AnyUrl.scheme
+builtins.str"builtins.strrC
+hostpydantic.networks.AnyUrl.host
+builtins.str"builtins.strrC
+pathpydantic.networks.AnyUrl.path
+builtins.str"builtins.strrC
+portpydantic.networks.AnyUrl.port
+builtins.int"builtins.intrm
+querypydantic.networks.AnyUrl.queryD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Noners
+fragment!pydantic.networks.AnyUrl.fragmentD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Noners
+username!pydantic.networks.AnyUrl.usernameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Noners
+password!pydantic.networks.AnyUrl.passwordD
+Union[builtins.str,None]
+builtins.str"builtins.str
+NoneD
+
+AnyHttpUrlpydantic.networks.AnyHttpUrl"pydantic.networks.AnyUrl>
+HttpUrlpydantic.networks.HttpUrl"pydantic.networks.AnyUrl>
+FileUrlpydantic.networks.FileUrl"pydantic.networks.AnyUrlN
+AnyWebsocketUrl!pydantic.networks.AnyWebsocketUrl"pydantic.networks.AnyUrlH
+WebsocketUrlpydantic.networks.WebsocketUrl"pydantic.networks.AnyUrl<
+FtpUrlpydantic.networks.FtpUrl"pydantic.networks.AnyUrl>
+AmqpDsnpydantic.networks.AmqpDsn"pydantic.networks.AnyUrlH
+CockroachDsnpydantic.networks.CockroachDsn"pydantic.networks.AnyUrl@
+KafkaDsnpydantic.networks.KafkaDsn"pydantic.networks.AnyUrl@
+RedisDsnpydantic.networks.RedisDsn"pydantic.networks.AnyUrlF
+PostgresDsnpydantic.networks.PostgresDsn"pydantic.networks.AnyUrl@
+MongoDsnpydantic.networks.MongoDsn"pydantic.networks.AnyUrl	
+Urlpydantic.networks.Url"builtins.object*
+unicode_string$pydantic.networks.Url.unicode_string"
+builtins.str"builtins.str*8
+self.
+pydantic.networks.Url"pydantic.networks.Url*
+unicode_host"pydantic.networks.Url.unicode_host"
+builtins.str"builtins.str*8
+self.
+pydantic.networks.Url"pydantic.networks.Url*
+query_params"pydantic.networks.Url.query_params",
+builtins.list[Any]
+Any"
builtins.list*8
+self.
+pydantic.networks.Url"pydantic.networks.UrlrD
+schemepydantic.networks.Url.scheme
+builtins.str"builtins.strr@
+hostpydantic.networks.Url.host
+builtins.str"builtins.strr@
+pathpydantic.networks.Url.path
+builtins.str"builtins.strr@
+portpydantic.networks.Url.port
+builtins.int"builtins.intrj
+querypydantic.networks.Url.queryD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerp
+fragmentpydantic.networks.Url.fragmentD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerp
+usernamepydantic.networks.Url.usernameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerp
+passwordpydantic.networks.Url.passwordD
+Union[builtins.str,None]
+builtins.str"builtins.str
+NoneA
+
IPvAnyAddresspydantic.networks.IPvAnyAddress"builtins.objectE
+IPvAnyInterface!pydantic.networks.IPvAnyInterface"builtins.objectA
+
IPvAnyNetworkpydantic.networks.IPvAnyNetwork"builtins.object4
+EmailStrpydantic.networks.EmailStr"builtins.str9
+	NameEmailpydantic.networks.NameEmail"builtins.object*
+__annotations__!pydantic.networks.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.protobuf
new file mode 100644
index 0000000000..e9a3d4e6c0
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.protobuf
@@ -0,0 +1,328 @@
+
+pydantic
+
+ConfigDictpydantic.config.ConfigDict"builtins.object*
+__init__#pydantic.config.ConfigDict.__init__"
+None*B
+self8
+pydantic.config.ConfigDict"pydantic.config.ConfigDict*
+kwargs
+Any7
+	FieldInfopydantic.fields.FieldInfo"builtins.object
+PrivateAttrpydantic.fields.PrivateAttr"builtins.object*
+__init__$pydantic.fields.PrivateAttr.__init__"
+None*D
+self:
+pydantic.fields.PrivateAttr"pydantic.fields.PrivateAttr*
+default
+Any *
+kwargs
+Any5
+	BaseModelpydantic.main.BaseModel"builtins.object
+	SecretStrpydantic.types.SecretStr"builtins.object*
+__init__!pydantic.types.SecretStr.__init__"
+None*>
+self4
+pydantic.types.SecretStr"pydantic.types.SecretStr*.
+secret_value
+builtins.str"builtins.str*
+get_secret_value)pydantic.types.SecretStr.get_secret_value"
+builtins.str"builtins.str*>
+self4
+pydantic.types.SecretStr"pydantic.types.SecretStr1
+ByteSizepydantic.types.ByteSize"builtins.int,
+Jsonpydantic.types.Json"builtins.object<
+ImportStringpydantic.types.ImportString"builtins.objectF
+StringConstraints pydantic.types.StringConstraints"builtins.objectF
+PaymentCardNumber pydantic.types.PaymentCardNumber"builtins.object2
+PastDatepydantic.types.PastDate"
datetime.date6
+
+FutureDatepydantic.types.FutureDate"
datetime.date>
+PastDatetimepydantic.types.PastDatetime"datetime.datetimeB
+FutureDatetimepydantic.types.FutureDatetime"datetime.datetime@
+
AwareDatetimepydantic.types.AwareDatetime"datetime.datetime@
+
NaiveDatetimepydantic.types.NaiveDatetime"datetime.datetime
+conintpydantic.types.conint"builtins.int*
+__init__pydantic.types.conint.__init__"
+None*8
+self.
+pydantic.types.conint"pydantic.types.conint*,
+strict
+
builtins.bool"
builtins.bool *&
+gt
+builtins.int"builtins.int *&
+ge
+builtins.int"builtins.int *&
+lt
+builtins.int"builtins.int *&
+le
+builtins.int"builtins.int */
+multiple_of
+builtins.int"builtins.int 
+conlistpydantic.types.conlist"
builtins.list*
+__init__pydantic.types.conlist.__init__"
+None*:
+self0
+pydantic.types.conlist"pydantic.types.conlist*
+	item_type
+Any *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int 
+consetpydantic.types.conset"builtins.set*
+__init__pydantic.types.conset.__init__"
+None*8
+self.
+pydantic.types.conset"pydantic.types.conset*
+	item_type
+Any *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int 
+confrozensetpydantic.types.confrozenset"builtins.frozenset*
+__init__$pydantic.types.confrozenset.__init__"
+None*D
+self:
+pydantic.types.confrozenset"pydantic.types.confrozenset*
+	item_type
+Any *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int 
+conbytespydantic.types.conbytes"builtins.bytes*
+__init__ pydantic.types.conbytes.__init__"
+None*<
+self2
+pydantic.types.conbytes"pydantic.types.conbytes*,
+strict
+
builtins.bool"
builtins.bool *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int 
+constrpydantic.types.constr"builtins.str*
+__init__pydantic.types.constr.__init__"
+None*8
+self.
+pydantic.types.constr"pydantic.types.constr*6
+strip_whitespace
+
builtins.bool"
builtins.bool *.
+to_upper
+
builtins.bool"
builtins.bool *.
+to_lower
+
builtins.bool"
builtins.bool *,
+strict
+
builtins.bool"
builtins.bool *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int *+
+pattern
+builtins.str"builtins.str *0
+
+ascii_only
+
builtins.bool"
builtins.bool 
+confloatpydantic.types.confloat"builtins.float*
+__init__ pydantic.types.confloat.__init__"
+None*<
+self2
+pydantic.types.confloat"pydantic.types.confloat*,
+strict
+
builtins.bool"
builtins.bool **
+gt 
+builtins.float"builtins.float **
+ge 
+builtins.float"builtins.float **
+lt 
+builtins.float"builtins.float **
+le 
+builtins.float"builtins.float *3
+multiple_of 
+builtins.float"builtins.float *3
+
allow_inf_nan
+
builtins.bool"
builtins.bool 
+
+condecimalpydantic.types.condecimal"_decimal.Decimal*
+__init__"pydantic.types.condecimal.__init__"
+None*@
+self6
+pydantic.types.condecimal"pydantic.types.condecimal*,
+strict
+
builtins.bool"
builtins.bool *
+gt
+Any *
+ge
+Any *
+lt
+Any *
+le
+Any *
+multiple_of
+Any *.
+
+max_digits
+builtins.int"builtins.int *2
+decimal_places
+builtins.int"builtins.int *3
+
allow_inf_nan
+
builtins.bool"
builtins.bool 
+condatepydantic.types.condate"
datetime.date*
+__init__pydantic.types.condate.__init__"
+None*:
+self0
+pydantic.types.condate"pydantic.types.condate*,
+strict
+
builtins.bool"
builtins.bool *(
+gt
+
datetime.date"
datetime.date *(
+ge
+
datetime.date"
datetime.date *(
+lt
+
datetime.date"
datetime.date *(
+le
+
datetime.date"
datetime.date 3
+	StrictStrpydantic.types.StrictStr"builtins.str7
+PositiveIntpydantic.types.PositiveInt"builtins.int7
+NegativeIntpydantic.types.NegativeInt"builtins.int=
+NonNegativeIntpydantic.types.NonNegativeInt"builtins.int=
+NonPositiveIntpydantic.types.NonPositiveInt"builtins.int=
+
PositiveFloatpydantic.types.PositiveFloat"builtins.float=
+
NegativeFloatpydantic.types.NegativeFloat"builtins.floatC
+NonNegativeFloatpydantic.types.NonNegativeFloat"builtins.floatC
+NonPositiveFloatpydantic.types.NonPositiveFloat"builtins.float9
+FiniteFloatpydantic.types.FiniteFloat"builtins.float1
+FilePathpydantic.types.FilePath"pathlib.Path;
+
DirectoryPathpydantic.types.DirectoryPath"pathlib.Path/
+NewPathpydantic.types.NewPath"pathlib.Path9
+Base64Bytespydantic.types.Base64Bytes"builtins.bytes?
+Base64UrlBytespydantic.types.Base64UrlBytes"builtins.bytes3
+	Base64Strpydantic.types.Base64Str"builtins.str9
+Base64UrlStrpydantic.types.Base64UrlStr"builtins.str(
+UUID1pydantic.types.UUID1"	uuid.UUID(
+UUID3pydantic.types.UUID3"	uuid.UUID(
+UUID4pydantic.types.UUID4"	uuid.UUID(
+UUID5pydantic.types.UUID5"	uuid.UUID
+AnyUrlpydantic.networks.AnyUrl"builtins.object*
+unicode_string'pydantic.networks.AnyUrl.unicode_string"
+builtins.str"builtins.str*>
+self4
+pydantic.networks.AnyUrl"pydantic.networks.AnyUrl*
+unicode_host%pydantic.networks.AnyUrl.unicode_host"
+builtins.str"builtins.str*>
+self4
+pydantic.networks.AnyUrl"pydantic.networks.AnyUrl*
+query_params%pydantic.networks.AnyUrl.query_params",
+builtins.list[Any]
+Any"
builtins.list*>
+self4
+pydantic.networks.AnyUrl"pydantic.networks.AnyUrl*
+encoded_string'pydantic.networks.AnyUrl.encoded_string"
+builtins.str"builtins.str*>
+self4
+pydantic.networks.AnyUrl"pydantic.networks.AnyUrlrG
+schemepydantic.networks.AnyUrl.scheme
+builtins.str"builtins.strrC
+hostpydantic.networks.AnyUrl.host
+builtins.str"builtins.strrC
+pathpydantic.networks.AnyUrl.path
+builtins.str"builtins.strrC
+portpydantic.networks.AnyUrl.port
+builtins.int"builtins.intrm
+querypydantic.networks.AnyUrl.queryD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Noners
+fragment!pydantic.networks.AnyUrl.fragmentD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Noners
+username!pydantic.networks.AnyUrl.usernameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Noners
+password!pydantic.networks.AnyUrl.passwordD
+Union[builtins.str,None]
+builtins.str"builtins.str
+NoneD
+
+AnyHttpUrlpydantic.networks.AnyHttpUrl"pydantic.networks.AnyUrl>
+HttpUrlpydantic.networks.HttpUrl"pydantic.networks.AnyUrl>
+FileUrlpydantic.networks.FileUrl"pydantic.networks.AnyUrlN
+AnyWebsocketUrl!pydantic.networks.AnyWebsocketUrl"pydantic.networks.AnyUrlH
+WebsocketUrlpydantic.networks.WebsocketUrl"pydantic.networks.AnyUrl<
+FtpUrlpydantic.networks.FtpUrl"pydantic.networks.AnyUrl>
+AmqpDsnpydantic.networks.AmqpDsn"pydantic.networks.AnyUrlH
+CockroachDsnpydantic.networks.CockroachDsn"pydantic.networks.AnyUrl@
+KafkaDsnpydantic.networks.KafkaDsn"pydantic.networks.AnyUrl@
+RedisDsnpydantic.networks.RedisDsn"pydantic.networks.AnyUrlF
+PostgresDsnpydantic.networks.PostgresDsn"pydantic.networks.AnyUrl@
+MongoDsnpydantic.networks.MongoDsn"pydantic.networks.AnyUrl	
+Urlpydantic.networks.Url"builtins.object*
+unicode_string$pydantic.networks.Url.unicode_string"
+builtins.str"builtins.str*8
+self.
+pydantic.networks.Url"pydantic.networks.Url*
+unicode_host"pydantic.networks.Url.unicode_host"
+builtins.str"builtins.str*8
+self.
+pydantic.networks.Url"pydantic.networks.Url*
+query_params"pydantic.networks.Url.query_params",
+builtins.list[Any]
+Any"
builtins.list*8
+self.
+pydantic.networks.Url"pydantic.networks.UrlrD
+schemepydantic.networks.Url.scheme
+builtins.str"builtins.strr@
+hostpydantic.networks.Url.host
+builtins.str"builtins.strr@
+pathpydantic.networks.Url.path
+builtins.str"builtins.strr@
+portpydantic.networks.Url.port
+builtins.int"builtins.intrj
+querypydantic.networks.Url.queryD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerp
+fragmentpydantic.networks.Url.fragmentD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerp
+usernamepydantic.networks.Url.usernameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerp
+passwordpydantic.networks.Url.passwordD
+Union[builtins.str,None]
+builtins.str"builtins.str
+NoneA
+
IPvAnyAddresspydantic.networks.IPvAnyAddress"builtins.objectE
+IPvAnyInterface!pydantic.networks.IPvAnyInterface"builtins.objectA
+
IPvAnyNetworkpydantic.networks.IPvAnyNetwork"builtins.object4
+EmailStrpydantic.networks.EmailStr"builtins.str9
+	NameEmailpydantic.networks.NameEmail"builtins.objectT
+Fieldpydantic.fields.Field"
+Any*
+default
+Any *
+kwargs
+Any*i
+__path__pydantic.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__pydantic.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.types.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.types.protobuf
new file mode 100644
index 0000000000..f79d6434fa
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic.types.protobuf
@@ -0,0 +1,202 @@
+
+pydantic.types
+	SecretStrpydantic.types.SecretStr"builtins.object*
+__init__!pydantic.types.SecretStr.__init__"
+None*>
+self4
+pydantic.types.SecretStr"pydantic.types.SecretStr*.
+secret_value
+builtins.str"builtins.str*
+get_secret_value)pydantic.types.SecretStr.get_secret_value"
+builtins.str"builtins.str*>
+self4
+pydantic.types.SecretStr"pydantic.types.SecretStr1
+ByteSizepydantic.types.ByteSize"builtins.int,
+Jsonpydantic.types.Json"builtins.object<
+ImportStringpydantic.types.ImportString"builtins.objectF
+StringConstraints pydantic.types.StringConstraints"builtins.objectF
+PaymentCardNumber pydantic.types.PaymentCardNumber"builtins.object2
+PastDatepydantic.types.PastDate"
datetime.date6
+
+FutureDatepydantic.types.FutureDate"
datetime.date>
+PastDatetimepydantic.types.PastDatetime"datetime.datetimeB
+FutureDatetimepydantic.types.FutureDatetime"datetime.datetime@
+
AwareDatetimepydantic.types.AwareDatetime"datetime.datetime@
+
NaiveDatetimepydantic.types.NaiveDatetime"datetime.datetime
+conintpydantic.types.conint"builtins.int*
+__init__pydantic.types.conint.__init__"
+None*8
+self.
+pydantic.types.conint"pydantic.types.conint*,
+strict
+
builtins.bool"
builtins.bool *&
+gt
+builtins.int"builtins.int *&
+ge
+builtins.int"builtins.int *&
+lt
+builtins.int"builtins.int *&
+le
+builtins.int"builtins.int */
+multiple_of
+builtins.int"builtins.int 
+conlistpydantic.types.conlist"
builtins.list*
+__init__pydantic.types.conlist.__init__"
+None*:
+self0
+pydantic.types.conlist"pydantic.types.conlist*
+	item_type
+Any *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int 
+consetpydantic.types.conset"builtins.set*
+__init__pydantic.types.conset.__init__"
+None*8
+self.
+pydantic.types.conset"pydantic.types.conset*
+	item_type
+Any *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int 
+confrozensetpydantic.types.confrozenset"builtins.frozenset*
+__init__$pydantic.types.confrozenset.__init__"
+None*D
+self:
+pydantic.types.confrozenset"pydantic.types.confrozenset*
+	item_type
+Any *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int 
+conbytespydantic.types.conbytes"builtins.bytes*
+__init__ pydantic.types.conbytes.__init__"
+None*<
+self2
+pydantic.types.conbytes"pydantic.types.conbytes*,
+strict
+
builtins.bool"
builtins.bool *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int 
+constrpydantic.types.constr"builtins.str*
+__init__pydantic.types.constr.__init__"
+None*8
+self.
+pydantic.types.constr"pydantic.types.constr*6
+strip_whitespace
+
builtins.bool"
builtins.bool *.
+to_upper
+
builtins.bool"
builtins.bool *.
+to_lower
+
builtins.bool"
builtins.bool *,
+strict
+
builtins.bool"
builtins.bool *.
+
+min_length
+builtins.int"builtins.int *.
+
+max_length
+builtins.int"builtins.int *+
+pattern
+builtins.str"builtins.str *0
+
+ascii_only
+
builtins.bool"
builtins.bool 
+confloatpydantic.types.confloat"builtins.float*
+__init__ pydantic.types.confloat.__init__"
+None*<
+self2
+pydantic.types.confloat"pydantic.types.confloat*,
+strict
+
builtins.bool"
builtins.bool **
+gt 
+builtins.float"builtins.float **
+ge 
+builtins.float"builtins.float **
+lt 
+builtins.float"builtins.float **
+le 
+builtins.float"builtins.float *3
+multiple_of 
+builtins.float"builtins.float *3
+
allow_inf_nan
+
builtins.bool"
builtins.bool 
+
+condecimalpydantic.types.condecimal"_decimal.Decimal*
+__init__"pydantic.types.condecimal.__init__"
+None*@
+self6
+pydantic.types.condecimal"pydantic.types.condecimal*,
+strict
+
builtins.bool"
builtins.bool *
+gt
+Any *
+ge
+Any *
+lt
+Any *
+le
+Any *
+multiple_of
+Any *.
+
+max_digits
+builtins.int"builtins.int *2
+decimal_places
+builtins.int"builtins.int *3
+
allow_inf_nan
+
builtins.bool"
builtins.bool 
+condatepydantic.types.condate"
datetime.date*
+__init__pydantic.types.condate.__init__"
+None*:
+self0
+pydantic.types.condate"pydantic.types.condate*,
+strict
+
builtins.bool"
builtins.bool *(
+gt
+
datetime.date"
datetime.date *(
+ge
+
datetime.date"
datetime.date *(
+lt
+
datetime.date"
datetime.date *(
+le
+
datetime.date"
datetime.date 3
+	StrictStrpydantic.types.StrictStr"builtins.str7
+PositiveIntpydantic.types.PositiveInt"builtins.int7
+NegativeIntpydantic.types.NegativeInt"builtins.int=
+NonNegativeIntpydantic.types.NonNegativeInt"builtins.int=
+NonPositiveIntpydantic.types.NonPositiveInt"builtins.int=
+
PositiveFloatpydantic.types.PositiveFloat"builtins.float=
+
NegativeFloatpydantic.types.NegativeFloat"builtins.floatC
+NonNegativeFloatpydantic.types.NonNegativeFloat"builtins.floatC
+NonPositiveFloatpydantic.types.NonPositiveFloat"builtins.float9
+FiniteFloatpydantic.types.FiniteFloat"builtins.float1
+FilePathpydantic.types.FilePath"pathlib.Path;
+
DirectoryPathpydantic.types.DirectoryPath"pathlib.Path/
+NewPathpydantic.types.NewPath"pathlib.Path9
+Base64Bytespydantic.types.Base64Bytes"builtins.bytes?
+Base64UrlBytespydantic.types.Base64UrlBytes"builtins.bytes3
+	Base64Strpydantic.types.Base64Str"builtins.str9
+Base64UrlStrpydantic.types.Base64UrlStr"builtins.str(
+UUID1pydantic.types.UUID1"	uuid.UUID(
+UUID3pydantic.types.UUID3"	uuid.UUID(
+UUID4pydantic.types.UUID4"	uuid.UUID(
+UUID5pydantic.types.UUID5"	uuid.UUID*
+__annotations__pydantic.types.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic_core.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic_core.protobuf
new file mode 100644
index 0000000000..c4d5a5af85
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pydantic_core.protobuf
@@ -0,0 +1,135 @@
+
+
pydantic_core
+Urlpydantic_core.Url"builtins.object*
+unicode_string pydantic_core.Url.unicode_string"
+builtins.str"builtins.str*0
+self&
+pydantic_core.Url"pydantic_core.Url*~
+unicode_hostpydantic_core.Url.unicode_host"
+builtins.str"builtins.str*0
+self&
+pydantic_core.Url"pydantic_core.Url*
+query_paramspydantic_core.Url.query_params",
+builtins.list[Any]
+Any"
builtins.list*0
+self&
+pydantic_core.Url"pydantic_core.Urlr@
+schemepydantic_core.Url.scheme
+builtins.str"builtins.strr<
+hostpydantic_core.Url.host
+builtins.str"builtins.strr<
+pathpydantic_core.Url.path
+builtins.str"builtins.strr<
+portpydantic_core.Url.port
+builtins.int"builtins.intrf
+querypydantic_core.Url.queryD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerl
+fragmentpydantic_core.Url.fragmentD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerl
+usernamepydantic_core.Url.usernameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerl
+passwordpydantic_core.Url.passwordD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None
+to_jsonpydantic_core.to_json" 
+builtins.bytes"builtins.bytes*
+value
+Any*R
+indentD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *2
+ensure_ascii
+
builtins.bool"
builtins.bool *
+include
+Any *
+exclude
+Any *.
+by_alias
+
builtins.bool"
builtins.bool *2
+exclude_none
+
builtins.bool"
builtins.bool *0
+
+round_trip
+
builtins.bool"
builtins.bool *2
+timedelta_mode
+builtins.str"builtins.str *1
+
temporal_mode
+builtins.str"builtins.str *.
+
+bytes_mode
+builtins.str"builtins.str *0
+inf_nan_mode
+builtins.str"builtins.str *7
+serialize_unknown
+
builtins.bool"
builtins.bool *
+fallback
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *6
+serialize_as_any
+
builtins.bool"
builtins.bool *h
+polymorphic_serializationG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *5
+context&
+Union[Any,None]
+Any
+None 
+to_jsonable_python pydantic_core.to_jsonable_python"
+Any*
+value
+Any*
+include
+Any *
+exclude
+Any *.
+by_alias
+
builtins.bool"
builtins.bool *2
+exclude_none
+
builtins.bool"
builtins.bool *0
+
+round_trip
+
builtins.bool"
builtins.bool *2
+timedelta_mode
+builtins.str"builtins.str *1
+
temporal_mode
+builtins.str"builtins.str *.
+
+bytes_mode
+builtins.str"builtins.str *0
+inf_nan_mode
+builtins.str"builtins.str *7
+serialize_unknown
+
builtins.bool"
builtins.bool *
+fallback
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *6
+serialize_as_any
+
builtins.bool"
builtins.bool *h
+polymorphic_serializationG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *5
+context&
+Union[Any,None]
+Any
+None *n
+__path__pydantic_core.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__pydantic_core.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pytest.mark.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pytest.mark.protobuf
new file mode 100644
index 0000000000..4d89c23c28
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pytest.mark.protobuf
@@ -0,0 +1,46 @@
+
+pytest.mark
+xfailpytest.mark.xfail"K
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+args
+Any**
+reason
+builtins.str"builtins.str *
+kwargs
+Any
+skippytest.mark.skip"K
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+args
+Any**
+reason
+builtins.str"builtins.str *
+kwargs
+Any
+usefixturespytest.mark.usefixtures"K
+CallableType[builtins.function]&
+builtins.function"builtins.function**
+fixtures
+builtins.str"builtins.str
+parametrizepytest.mark.parametrize"K
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+argnames
+1Union[builtins.str,typing.Sequence[builtins.str]]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence*1
+	argvalues"
+builtins.object"builtins.object*
+args
+Any*
+kwargs
+Any*l
+__path__pytest.mark.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__pytest.mark.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pytest.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pytest.protobuf
new file mode 100644
index 0000000000..ccfecf04a1
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/custom_protobuf/pytest.protobuf
@@ -0,0 +1,49 @@
+
+pytestO
+ApproxScalarpytest.ApproxScalar"*SonarPythonAnalyzerFakeStub.CustomStubBase
+approx
pytest.approx"*
+pytest.ApproxScalar"pytest.ApproxScalar*2
+expected"
+builtins.object"builtins.object *,
+args"
+builtins.object"builtins.object*.
+kwargs"
+builtins.object"builtins.object
+fixturepytest.fixture"
+Any*,
+args"
+builtins.object"builtins.object*.
+kwargs"
+builtins.object"builtins.object
+
yield_fixturepytest.yield_fixture"
+Any*,
+args"
+builtins.object"builtins.object*.
+kwargs"
+builtins.object"builtins.objectz
+failpytest.fail"
+Any*,
+args"
+builtins.object"builtins.object*.
+kwargs"
+builtins.object"builtins.object~
+raises
pytest.raises"
+Any*,
+args"
+builtins.object"builtins.object*.
+kwargs"
+builtins.object"builtins.object|
+warnspytest.warns"
+Any*,
+args"
+builtins.object"builtins.object*.
+kwargs"
+builtins.object"builtins.object*g
+__path__pytest.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__pytest.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*
+markpytest.mark 
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.core.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.core.protobuf
index b4830c4ea5..2236cd523c 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.core.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.core.protobuf
@@ -1,9 +1,108 @@
 
-	idna.core7
-	IDNAErroridna.core.IDNAError"builtins.UnicodeError=
+	idna.core!
+	IDNAErroridna.core.IDNAError"builtins.UnicodeError*
+__init__idna.core.IDNAError.__init__"
+None*4
+self*
+idna.core.IDNAError"idna.core.IDNAError*,
+args"
+builtins.object"builtins.object*
+code
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"idna.core._ErrorCode
+None *P
+textD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *U
+	codepointD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+positionD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None rf
+codeidna.core.IDNAError.codeD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerf
+textidna.core.IDNAError.textD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerp
+	codepointidna.core.IDNAError.codepointD
+Union[builtins.int,None]
+builtins.int"builtins.int
+Nonern
+positionidna.core.IDNAError.positionD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None=
 
IDNABidiErroridna.core.IDNABidiError"idna.core.IDNAErrorC
 InvalidCodepointidna.core.InvalidCodepoint"idna.core.IDNAErrorQ
-InvalidCodepointContext!idna.core.InvalidCodepointContext"idna.core.IDNAErrorr
+InvalidCodepointContext!idna.core.InvalidCodepointContext"idna.core.IDNAError
+
_joining_typeidna.core._joining_type"D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*$
+cp
+builtins.int"builtins.intr
 _combining_classidna.core._combining_class"
 builtins.int"builtins.int*$
 cp
@@ -28,10 +127,10 @@ _is_scriptidna.core._is_script"
 labelf
 "Union[builtins.bytes,builtins.str] 
 builtins.bytes"builtins.bytes
-builtins.str"builtins.str
+builtins.str"builtins.str
 valid_string_lengthidna.core.valid_string_length"
-
builtins.bool"
builtins.bool*q
-labelf
+
builtins.bool"
builtins.bool*r
+domainf
 "Union[builtins.bytes,builtins.str] 
 builtins.bytes"builtins.bytes
 builtins.str"builtins.str*0
@@ -87,7 +186,17 @@ check_bidiidna.core.check_bidi"
 5Union[builtins.str,builtins.bytes,builtins.bytearray]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes(
-builtins.bytearray"builtins.bytearray
+builtins.bytearray"builtins.bytearray
+_check_std3idna.core._check_std3"
+None*&
+text
+builtins.str"builtins.str*(
+domain
+builtins.str"builtins.str*(
+offset
+builtins.int"builtins.int<
+_warn_transitionalidna.core._warn_transitional"
+None
 uts46_remapidna.core.uts46_remap"
 builtins.str"builtins.str*(
 domain
@@ -112,7 +221,7 @@ std3_rules
 std3_rules
 
builtins.bool"
builtins.bool *2
 transitional
-
builtins.bool"
builtins.bool 
+
builtins.bool"
builtins.bool 
 decodeidna.core.decode"
 builtins.str"builtins.str*
 s
@@ -126,6 +235,8 @@ std3_rules
 
builtins.bool"
builtins.bool *0
 
 std3_rules
+
builtins.bool"
builtins.bool *-
+display
 
builtins.bool"
builtins.bool *
 __annotations__idna.core.__annotations__W
 builtins.dict[builtins.str,Any]
@@ -134,8 +245,49 @@ std3_rules
 _virama_combining_class!idna.core._virama_combining_class
 builtins.int"builtins.int*L
 _alabel_prefixidna.core._alabel_prefix 
-builtins.bytes"builtins.bytes*t
+builtins.bytes"builtins.bytes*N
+_max_input_lengthidna.core._max_input_length
+builtins.int"builtins.int*F
+
_STATUS_VALIDidna.core._STATUS_VALID
+builtins.int"builtins.int*H
+_STATUS_MAPPEDidna.core._STATUS_MAPPED
+builtins.int"builtins.int*N
+_STATUS_DEVIATIONidna.core._STATUS_DEVIATION
+builtins.int"builtins.int*J
+_STATUS_IGNOREDidna.core._STATUS_IGNORED
+builtins.int"builtins.int*t
 _unicode_dots_reidna.core._unicode_dots_reD
 re.Pattern[builtins.str]
 builtins.str"builtins.str"
-re.Pattern
\ No newline at end of file
+re.Pattern*z
+_std3_disallowed_reidna.core._std3_disallowed_reD
+re.Pattern[builtins.str]
+builtins.str"builtins.str"
+re.Pattern*
+_bidi_rtl_firstidna.core._bidi_rtl_firstT
+ builtins.frozenset[builtins.str]
+builtins.str"builtins.str"builtins.frozenset*
+_bidi_rtl_categoriesidna.core._bidi_rtl_categoriesT
+ builtins.frozenset[builtins.str]
+builtins.str"builtins.str"builtins.frozenset*
+_bidi_rtl_allowedidna.core._bidi_rtl_allowedT
+ builtins.frozenset[builtins.str]
+builtins.str"builtins.str"builtins.frozenset*
+_bidi_rtl_valid_ending idna.core._bidi_rtl_valid_endingT
+ builtins.frozenset[builtins.str]
+builtins.str"builtins.str"builtins.frozenset*
+_bidi_rtl_numericidna.core._bidi_rtl_numericT
+ builtins.frozenset[builtins.str]
+builtins.str"builtins.str"builtins.frozenset*
+_bidi_ltr_allowedidna.core._bidi_ltr_allowedT
+ builtins.frozenset[builtins.str]
+builtins.str"builtins.str"builtins.frozenset*
+_bidi_ltr_valid_ending idna.core._bidi_ltr_valid_endingT
+ builtins.frozenset[builtins.str]
+builtins.str"builtins.str"builtins.frozenset*
+_bidi_joiner_l_or_didna.core._bidi_joiner_l_or_dT
+ builtins.frozenset[builtins.str]
+builtins.str"builtins.str"builtins.frozenset*
+_bidi_joiner_r_or_didna.core._bidi_joiner_r_or_dT
+ builtins.frozenset[builtins.str]
+builtins.str"builtins.str"builtins.frozenset
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.idnadata.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.idnadata.protobuf
index 4181522dd0..28559c685d 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.idnadata.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.idnadata.protobuf
@@ -10,11 +10,12 @@
 8builtins.dict[builtins.str,builtins.tuple[builtins.int]]
 builtins.str"builtins.strL
 builtins.tuple[builtins.int]
-builtins.int"builtins.int"builtins.tuple"
builtins.dict*
-
joining_typesidna.idnadata.joining_typesu
-(builtins.dict[builtins.int,builtins.int]
-builtins.int"builtins.int
-builtins.int"builtins.int"
builtins.dict*
+builtins.int"builtins.int"builtins.tuple"
builtins.dict*
+
joining_typesidna.idnadata.joining_types
+8builtins.dict[builtins.str,builtins.tuple[builtins.int]]
+builtins.str"builtins.strL
+builtins.tuple[builtins.int]
+builtins.int"builtins.int"builtins.tuple"
builtins.dict*
 codepoint_classesidna.idnadata.codepoint_classes
 8builtins.dict[builtins.str,builtins.tuple[builtins.int]]
 builtins.str"builtins.strL
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.intranges.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.intranges.protobuf
index eaf9bc5875..b2e2ab2785 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.intranges.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.intranges.protobuf
@@ -1,8 +1,9 @@
 
-idna.intranges
-intranges_from_list"idna.intranges.intranges_from_list"L
-builtins.tuple[builtins.int]
-builtins.int"builtins.int"builtins.tuple*U
+idna.intranges
+intranges_from_list"idna.intranges.intranges_from_list"B
+Tuple[builtins.int,Any]
+builtins.int"builtins.int
+Any*U
 list_J
 builtins.list[builtins.int]
 builtins.int"builtins.int"
builtins.list
@@ -17,14 +18,15 @@
 builtins.int"builtins.int
 builtins.int"builtins.int*#
 r
-builtins.int"builtins.int
+builtins.int"builtins.int
 intranges_contain idna.intranges.intranges_contain"
 
builtins.bool"
builtins.bool*&
 int_
-builtins.int"builtins.int*X
-rangesL
-builtins.tuple[builtins.int]
-builtins.int"builtins.int"builtins.tuple*
+builtins.int"builtins.int*N
+rangesB
+Tuple[builtins.int,Any]
+builtins.int"builtins.int
+Any*
 __annotations__idna.intranges.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.protobuf
index 82180ba5cd..89050d4e56 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.protobuf
@@ -1,7 +1,100 @@
 
 idna=
-
IDNABidiErroridna.core.IDNABidiError"idna.core.IDNAError7
-	IDNAErroridna.core.IDNAError"builtins.UnicodeErrorC
+
IDNABidiErroridna.core.IDNABidiError"idna.core.IDNAError!
+	IDNAErroridna.core.IDNAError"builtins.UnicodeError*
+__init__idna.core.IDNAError.__init__"
+None*4
+self*
+idna.core.IDNAError"idna.core.IDNAError*,
+args"
+builtins.object"builtins.object*
+code
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"idna.core._ErrorCode
+None *P
+textD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *U
+	codepointD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+positionD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None rf
+codeidna.core.IDNAError.codeD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerf
+textidna.core.IDNAError.textD
+Union[builtins.str,None]
+builtins.str"builtins.str
+Nonerp
+	codepointidna.core.IDNAError.codepointD
+Union[builtins.int,None]
+builtins.int"builtins.int
+Nonern
+positionidna.core.IDNAError.positionD
+Union[builtins.int,None]
+builtins.int"builtins.int
+NoneC
 InvalidCodepointidna.core.InvalidCodepoint"idna.core.IDNAErrorQ
 InvalidCodepointContext!idna.core.InvalidCodepointContext"idna.core.IDNAErrore
 alabelidna.core.alabel" 
@@ -33,7 +126,7 @@ check_bidiidna.core.check_bidi"
 	check_nfcidna.core.check_nfc"
 None*'
 label
-builtins.str"builtins.str
+builtins.str"builtins.str
 decodeidna.core.decode"
 builtins.str"builtins.str*
 s
@@ -47,6 +140,8 @@ check_bidiidna.core.check_bidi"
 
builtins.bool"
builtins.bool *0
 
 std3_rules
+
builtins.bool"
builtins.bool *-
+display
 
builtins.bool"
builtins.bool 
 encodeidna.core.encode" 
 builtins.bytes"builtins.bytes*
@@ -99,22 +194,23 @@ std3_rules
 labelf
 "Union[builtins.bytes,builtins.str] 
 builtins.bytes"builtins.bytes
-builtins.str"builtins.str
+builtins.str"builtins.str
 valid_string_lengthidna.core.valid_string_length"
-
builtins.bool"
builtins.bool*q
-labelf
+
builtins.bool"
builtins.bool*r
+domainf
 "Union[builtins.bytes,builtins.str] 
 builtins.bytes"builtins.bytes
 builtins.str"builtins.str*0
 trailing_dot
-
builtins.bool"
builtins.bool
+
builtins.bool"
builtins.bool
 intranges_contain idna.intranges.intranges_contain"
 
builtins.bool"
builtins.bool*&
 int_
-builtins.int"builtins.int*X
-rangesL
-builtins.tuple[builtins.int]
-builtins.int"builtins.int"builtins.tuple*e
+builtins.int"builtins.int*N
+rangesB
+Tuple[builtins.int,Any]
+builtins.int"builtins.int
+Any*e
 __path__
idna.__path__J
 builtins.list[builtins.str]
 builtins.str"builtins.str"
builtins.list*
@@ -122,6 +218,8 @@ std3_rules
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
 Any"
builtins.dict*J
+unicode_versionidna.idnadata.__version__
+builtins.str"builtins.str*J
 __version__idna.package_data.__version__
 builtins.str"builtins.str*c
 __all__idna.__all__J
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.uts46data.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.uts46data.protobuf
index 9605fcc303..424efb3f09 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.uts46data.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/idna.uts46data.protobuf
@@ -1,858 +1,18 @@
 
-idna.uts46data
-_seg_0idna.uts46data._seg_0"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_1idna.uts46data._seg_1"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_2idna.uts46data._seg_2"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_3idna.uts46data._seg_3"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_4idna.uts46data._seg_4"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_5idna.uts46data._seg_5"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_6idna.uts46data._seg_6"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_7idna.uts46data._seg_7"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_8idna.uts46data._seg_8"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_9idna.uts46data._seg_9"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_10idna.uts46data._seg_10"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_11idna.uts46data._seg_11"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_12idna.uts46data._seg_12"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_13idna.uts46data._seg_13"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_14idna.uts46data._seg_14"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_15idna.uts46data._seg_15"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_16idna.uts46data._seg_16"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_17idna.uts46data._seg_17"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_18idna.uts46data._seg_18"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_19idna.uts46data._seg_19"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_20idna.uts46data._seg_20"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_21idna.uts46data._seg_21"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_22idna.uts46data._seg_22"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_23idna.uts46data._seg_23"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_24idna.uts46data._seg_24"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_25idna.uts46data._seg_25"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_26idna.uts46data._seg_26"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_27idna.uts46data._seg_27"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_28idna.uts46data._seg_28"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_29idna.uts46data._seg_29"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_30idna.uts46data._seg_30"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_31idna.uts46data._seg_31"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_32idna.uts46data._seg_32"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_33idna.uts46data._seg_33"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_34idna.uts46data._seg_34"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_35idna.uts46data._seg_35"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_36idna.uts46data._seg_36"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_37idna.uts46data._seg_37"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_38idna.uts46data._seg_38"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_39idna.uts46data._seg_39"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_40idna.uts46data._seg_40"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_41idna.uts46data._seg_41"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_42idna.uts46data._seg_42"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_43idna.uts46data._seg_43"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_44idna.uts46data._seg_44"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_45idna.uts46data._seg_45"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_46idna.uts46data._seg_46"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_47idna.uts46data._seg_47"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_48idna.uts46data._seg_48"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_49idna.uts46data._seg_49"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_50idna.uts46data._seg_50"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_51idna.uts46data._seg_51"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_52idna.uts46data._seg_52"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_53idna.uts46data._seg_53"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_54idna.uts46data._seg_54"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_55idna.uts46data._seg_55"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_56idna.uts46data._seg_56"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_57idna.uts46data._seg_57"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_58idna.uts46data._seg_58"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_59idna.uts46data._seg_59"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_60idna.uts46data._seg_60"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_61idna.uts46data._seg_61"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_62idna.uts46data._seg_62"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_63idna.uts46data._seg_63"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_64idna.uts46data._seg_64"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_65idna.uts46data._seg_65"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_66idna.uts46data._seg_66"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_67idna.uts46data._seg_67"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_68idna.uts46data._seg_68"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_69idna.uts46data._seg_69"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_70idna.uts46data._seg_70"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_71idna.uts46data._seg_71"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_72idna.uts46data._seg_72"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_73idna.uts46data._seg_73"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_74idna.uts46data._seg_74"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_75idna.uts46data._seg_75"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_76idna.uts46data._seg_76"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_77idna.uts46data._seg_77"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_78idna.uts46data._seg_78"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_79idna.uts46data._seg_79"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_80idna.uts46data._seg_80"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_81idna.uts46data._seg_81"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_82idna.uts46data._seg_82"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list
-_seg_83idna.uts46data._seg_83"
-dbuiltins.list[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"
builtins.list*
+idna.uts46data*
 __annotations__idna.uts46data.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
 Any"
builtins.dict*G
 __version__idna.uts46data.__version__
-builtins.str"builtins.str*
-	uts46dataidna.uts46data.uts46data
-ebuiltins.tuple[Union[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]]
-UUnion[Tuple[builtins.int,builtins.str],Tuple[builtins.int,builtins.str,builtins.str]]`
- Tuple[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
--Tuple[builtins.int,builtins.str,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str
-builtins.str"builtins.str"builtins.tuple
\ No newline at end of file
+builtins.str"builtins.str*s
+uts46_startsidna.uts46data.uts46_startsF
+array.array[builtins.int]
+builtins.int"builtins.int"array.array*Q
+uts46_statusesidna.uts46data.uts46_statuses 
+builtins.bytes"builtins.bytes*
+uts46_replacements!idna.uts46data.uts46_replacements
+(builtins.tuple[Union[builtins.str,None]]D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None"builtins.tuple
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._adapters.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._adapters.protobuf
new file mode 100644
index 0000000000..3aafc188e3
Binary files /dev/null and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._adapters.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._collections.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._collections.protobuf
new file mode 100644
index 0000000000..31154149e4
Binary files /dev/null and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._collections.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._compat.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._compat.protobuf
new file mode 100644
index 0000000000..4ef6a415bb
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._compat.protobuf
@@ -0,0 +1,20 @@
+
+importlib_metadata._compat
+
+NullFinder%importlib_metadata._compat.NullFinder"builtins.object*m
+	find_spec/importlib_metadata._compat.NullFinder.find_spec*
+args*
+
+kwargs0:builtins.staticmethodh6
+install"importlib_metadata._compat.install*
+clsI
+disable_stdlib_finder0importlib_metadata._compat.disable_stdlib_finder@
+pypy_partial'importlib_metadata._compat.pypy_partial*
+val*
+__annotations__*importlib_metadata._compat.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*y
+__all__"importlib_metadata._compat.__all__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._functools.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._functools.protobuf
new file mode 100644
index 0000000000..0a7e20dc89
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._functools.protobuf
@@ -0,0 +1,22 @@
+
+importlib_metadata._functools[
+method_cache*importlib_metadata._functools.method_cache*
+
+method*
+
cache_wrapper >
+	pass_none'importlib_metadata._functools.pass_none*
+func@
+noop"importlib_metadata._functools.noop*
+args*
+
+kwargs
+passthrough)importlib_metadata._functools.passthrough"K
+CallableType[builtins.function]&
+builtins.function"builtins.function*U
+funcK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+__annotations__-importlib_metadata._functools.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._itertools.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._itertools.protobuf
new file mode 100644
index 0000000000..d3f5cadcbb
Binary files /dev/null and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._itertools.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._meta.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._meta.protobuf
new file mode 100644
index 0000000000..986057a3ed
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._meta.protobuf
@@ -0,0 +1,116 @@
+
+importlib_metadata._meta
+PackageMetadata(importlib_metadata._meta.PackageMetadata"builtins.object*
+__len__0importlib_metadata._meta.PackageMetadata.__len__"
+builtins.int"builtins.int*VT
+(importlib_metadata._meta.PackageMetadata"(importlib_metadata._meta.PackageMetadata@*
+__contains__5importlib_metadata._meta.PackageMetadata.__contains__"
+
builtins.bool"
builtins.bool*VT
+(importlib_metadata._meta.PackageMetadata"(importlib_metadata._meta.PackageMetadata*
+builtins.str"builtins.str@*
+__getitem__4importlib_metadata._meta.PackageMetadata.__getitem__"
+builtins.str"builtins.str*VT
+(importlib_metadata._meta.PackageMetadata"(importlib_metadata._meta.PackageMetadata*
+builtins.str"builtins.str@*
+__iter__1importlib_metadata._meta.PackageMetadata.__iter__"N
+typing.Iterator[builtins.str]
+builtins.str"builtins.str"typing.Iterator*VT
+(importlib_metadata._meta.PackageMetadata"(importlib_metadata._meta.PackageMetadata@*
+json-importlib_metadata._meta.PackageMetadata.json"
+Kbuiltins.dict[builtins.str,Union[builtins.str,builtins.list[builtins.str]]]
+builtins.str"builtins.str
+/Union[builtins.str,builtins.list[builtins.str]]
+builtins.str"builtins.strJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list"
builtins.dict*^
+selfT
+(importlib_metadata._meta.PackageMetadata"(importlib_metadata._meta.PackageMetadata0:builtins.property@`2
+get,importlib_metadata._meta.PackageMetadata.get
+get,importlib_metadata._meta.PackageMetadata.get"D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*^
+selfT
+(importlib_metadata._meta.PackageMetadata"(importlib_metadata._meta.PackageMetadata*&
+name
+builtins.str"builtins.str*
+failobj
+None 0:typing.overload@X
+get,importlib_metadata._meta.PackageMetadata.get"
+/Union[builtins.str,importlib_metadata._meta._T]
+builtins.str"builtins.strT
+importlib_metadata._meta._T"
+builtins.object"builtins.object"builtins.object*^
+selfT
+(importlib_metadata._meta.PackageMetadata"(importlib_metadata._meta.PackageMetadata*&
+name
+builtins.str"builtins.str*a
+failobjT
+importlib_metadata._meta._T"
+builtins.object"builtins.object"builtins.object0:typing.overload@X2
+get_all0importlib_metadata._meta.PackageMetadata.get_all
+get_all0importlib_metadata._meta.PackageMetadata.get_all"Z
+Union[builtins.list[Any],None],
+builtins.list[Any]
+Any"
builtins.list
+None*^
+selfT
+(importlib_metadata._meta.PackageMetadata"(importlib_metadata._meta.PackageMetadata*&
+name
+builtins.str"builtins.str*
+failobj
+None 0:typing.overload@X
+get_all0importlib_metadata._meta.PackageMetadata.get_all"
+5Union[builtins.list[Any],importlib_metadata._meta._T],
+builtins.list[Any]
+Any"
builtins.listT
+importlib_metadata._meta._T"
+builtins.object"builtins.object"builtins.object*^
+selfT
+(importlib_metadata._meta.PackageMetadata"(importlib_metadata._meta.PackageMetadata*&
+name
+builtins.str"builtins.str*a
+failobjT
+importlib_metadata._meta._T"
+builtins.object"builtins.object"builtins.object0:typing.overload@XX
+
+SimplePath#importlib_metadata._meta.SimplePath"builtins.object*
+joinpath,importlib_metadata._meta.SimplePath.joinpath"J
+#importlib_metadata._meta.SimplePath"#importlib_metadata._meta.SimplePath*T
+selfJ
+#importlib_metadata._meta.SimplePath"#importlib_metadata._meta.SimplePath*
+other
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike@*
+__truediv__/importlib_metadata._meta.SimplePath.__truediv__"J
+#importlib_metadata._meta.SimplePath"#importlib_metadata._meta.SimplePath*LJ
+#importlib_metadata._meta.SimplePath"#importlib_metadata._meta.SimplePath*
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike@*
+parent*importlib_metadata._meta.SimplePath.parent"J
+#importlib_metadata._meta.SimplePath"#importlib_metadata._meta.SimplePath*T
+selfJ
+#importlib_metadata._meta.SimplePath"#importlib_metadata._meta.SimplePath0:builtins.property@`*
+	read_text-importlib_metadata._meta.SimplePath.read_text"
+builtins.str"builtins.str*T
+selfJ
+#importlib_metadata._meta.SimplePath"#importlib_metadata._meta.SimplePath*
+encoding
+Any @*
+
+read_bytes.importlib_metadata._meta.SimplePath.read_bytes" 
+builtins.bytes"builtins.bytes*T
+selfJ
+#importlib_metadata._meta.SimplePath"#importlib_metadata._meta.SimplePath@*
+exists*importlib_metadata._meta.SimplePath.exists"
+
builtins.bool"
builtins.bool*T
+selfJ
+#importlib_metadata._meta.SimplePath"#importlib_metadata._meta.SimplePath@X*
+__annotations__(importlib_metadata._meta.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._text.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._text.protobuf
new file mode 100644
index 0000000000..9cb1d096b6
Binary files /dev/null and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._text.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._typing.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._typing.protobuf
new file mode 100644
index 0000000000..c942400e81
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata._typing.protobuf
@@ -0,0 +1,10 @@
+
+importlib_metadata._typing*
+__annotations__*importlib_metadata._typing.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*
+md_none"importlib_metadata._typing.md_noneu
+functools.partial[typing._T]B
+	typing._T"
+builtins.object"builtins.object"builtins.object"functools.partial
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.compat.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.compat.protobuf
new file mode 100644
index 0000000000..c1a7f759c6
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.compat.protobuf
@@ -0,0 +1,9 @@
+
+importlib_metadata.compat*z
+__path__"importlib_metadata.compat.__path__J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+__annotations__)importlib_metadata.compat.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.compat.py311.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.compat.py311.protobuf
new file mode 100644
index 0000000000..0d4be375be
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.compat.py311.protobuf
@@ -0,0 +1,11 @@
+
+importlib_metadata.compat.py3116
+wrap$importlib_metadata.compat.py311.wrap*
+path*
+__annotations__/importlib_metadata.compat.py311.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*
+relative_fix,importlib_metadata.compat.py311.relative_fixK
+CallableType[builtins.function]&
+builtins.function"builtins.function
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.compat.py39.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.compat.py39.protobuf
new file mode 100644
index 0000000000..a37af88d70
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.compat.py39.protobuf
@@ -0,0 +1,19 @@
+
+importlib_metadata.compat.py39
+normalized_name.importlib_metadata.compat.py39.normalized_name"D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None*L
+distB
+importlib_metadata.Distribution"importlib_metadata.Distribution
+
+ep_matches)importlib_metadata.compat.py39.ep_matches"
+
builtins.bool"
builtins.bool*F
+ep>
+importlib_metadata.EntryPoint"importlib_metadata.EntryPoint*
+params
+Any*
+__annotations__.importlib_metadata.compat.py39.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.protobuf
new file mode 100644
index 0000000000..d4da6b905e
Binary files /dev/null and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/importlib_metadata.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._config.config.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._config.config.protobuf
index 83ca126156..86037f2698 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._config.config.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._config.config.protobuf
@@ -189,10 +189,15 @@ IOExcelXLS pandas._config.config.IOExcelXLS"!pandas._config.config.DictWrapperr
 parquet pandas._config.config.IO.parquetB
 pandas._config.config.IOParquet"pandas._config.config.IOParquetr_
 sqlpandas._config.config.IO.sql:
-pandas._config.config.IOSQL"pandas._config.config.IOSQL
-Modepandas._config.config.Mode"!pandas._config.config.DictWrapperra
-chained_assignment-pandas._config.config.Mode.chained_assignment
-builtins.str"builtins.strrU
+pandas._config.config.IOSQL"pandas._config.config.IOSQL
+Modepandas._config.config.Mode"!pandas._config.config.DictWrapperr
+chained_assignment-pandas._config.config.Mode.chained_assignment
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+NonerU
 data_manager'pandas._config.config.Mode.data_manager
 builtins.str"builtins.strr]
 sim_interactive*pandas._config.config.Mode.sim_interactive
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.lib.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.lib.protobuf
index 8a63477a3c..173ba9ccd3 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.lib.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.lib.protobuf
@@ -25,11 +25,7 @@ no_default&pandas._libs.lib._NoDefault.no_default&
 builtins.object"builtins.object*0
 
 allow_sets
-
builtins.bool"
builtins.bool x
-is_intervalpandas._libs.lib.is_interval"
-
builtins.bool"
builtins.bool*+
-val"
-builtins.object"builtins.objectv
+
builtins.bool"
builtins.bool v
 
 is_complexpandas._libs.lib.is_complex"
 
builtins.bool"
builtins.bool*+
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.properties.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.properties.protobuf
new file mode 100644
index 0000000000..94dd32b5a6
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.properties.protobuf
@@ -0,0 +1,47 @@
+
+pandas._libs.properties
+CachedProperty&pandas._libs.properties.CachedProperty"builtins.object*
+__init__/pandas._libs.properties.CachedProperty.__init__"
+None*Z
+selfP
+&pandas._libs.properties.CachedProperty"&pandas._libs.properties.CachedProperty*U
+funcK
+CallableType[builtins.function]&
+builtins.function"builtins.function*U
+__get__.pandas._libs.properties.CachedProperty.__get__*
+self*
+obj*
+typ*
+__set__.pandas._libs.properties.CachedProperty.__set__"
+None*Z
+selfP
+&pandas._libs.properties.CachedProperty"&pandas._libs.properties.CachedProperty*
+obj
+Any*
+value
+Any
+AxisProperty$pandas._libs.properties.AxisProperty"builtins.object*
+__init__-pandas._libs.properties.AxisProperty.__init__"
+None*V
+selfL
+$pandas._libs.properties.AxisProperty"$pandas._libs.properties.AxisProperty*(
+axis
+builtins.int"builtins.int *'
+doc
+builtins.str"builtins.str *S
+__get__,pandas._libs.properties.AxisProperty.__get__*
+self*
+obj*
+typ*
+__set__,pandas._libs.properties.AxisProperty.__set__"
+None*V
+selfL
+$pandas._libs.properties.AxisProperty"$pandas._libs.properties.AxisProperty*
+obj
+Any*
+value
+Any*
+__annotations__'pandas._libs.properties.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.protobuf
index e77c882487..7298564ea5 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.protobuf
@@ -672,8 +672,12 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 mid"pandas._libs.interval.Interval.midL
 $pandas._libs.interval._MidDescriptor"$pandas._libs.interval._MidDescriptorr
 length%pandas._libs.interval.Interval.lengthR
-'pandas._libs.interval._LengthDescriptor"'pandas._libs.interval._LengthDescriptor^
+'pandas._libs.interval._LengthDescriptor"'pandas._libs.interval._LengthDescriptork
 NaTType#pandas._libs.tslibs.nattype.NaTType"builtins.object*
+__hash__,pandas._libs.tslibs.nattype.NaTType.__hash__"
+builtins.int"builtins.int*T
+selfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*
 asm8(pandas._libs.tslibs.nattype.NaTType.asm8"$
 numpy.datetime64"numpy.datetime64*T
 selfJ
@@ -933,7 +937,39 @@ nanosecond.pandas._libs.tslibs.nattype.NaTType.nanosecond"
 __ne__*pandas._libs.tslibs.nattype.NaTType.__ne__"
 
builtins.bool"
builtins.bool*LJ
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*$"
-builtins.object"builtins.objectr
+builtins.object"builtins.object*
+unit(pandas._libs.tslibs.nattype.NaTType.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*T
+selfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:builtins.property`*
+as_unit+pandas._libs.tslibs.nattype.NaTType.as_unit"
+(pandas._libs.tslibs.nattype.NaTType.SelfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType(*
+self
+(pandas._libs.tslibs.nattype.NaTType.SelfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool r
 value)pandas._libs.tslibs.nattype.NaTType.value
 4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
 )numpy.signedinteger[numpy._typing._64Bit],
@@ -1378,8 +1414,8 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 __radd__*pandas._libs.tslibs.period.Period.__radd__"J
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*HF
 !pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*LJ
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
-	Timedelta(pandas._libs.tslibs.timedeltas.Timedelta"datetime.timedelta*5
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
+	Timedelta(pandas._libs.tslibs.timedeltas.Timedelta"datetime.timedelta*-
 __new__0pandas._libs.tslibs.timedeltas.Timedelta.__new__"
 -pandas._libs.tslibs.timedeltas.Timedelta.SelfT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
@@ -1393,30 +1429,10 @@ nUnion[builtins.str,builtins.int,pandas._libs.tslibs.timedeltas.Timedelta,dateti
 builtins.int"builtins.intT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
 datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64 *#
-unit#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+numpy.timedelta64"numpy.timedelta64 *
+unit
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -1674,7 +1690,39 @@ aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[T
 builtins.list[Any]
 Any"
builtins.listM
 TypeAlias[TypedDict]
-	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike 2+
+	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike *
+unit-pandas._libs.tslibs.timedeltas.Timedelta.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*^
+selfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta0:builtins.property`*
+as_unit0pandas._libs.tslibs.timedeltas.Timedelta.as_unit"
+-pandas._libs.tslibs.timedeltas.Timedelta.SelfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
+self
+-pandas._libs.tslibs.timedeltas.Timedelta.SelfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool 2+
 __add__0pandas._libs.tslibs.timedeltas.Timedelta.__add__
 __add__0pandas._libs.tslibs.timedeltas.Timedelta.__add__"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*VT
@@ -1838,7 +1886,7 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 mUnion[pandas.core.series.TimedeltaSeries,pandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]]H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries
 Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series0:typing.overloadX2$
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series0:typing.overloadX2$
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*VT
@@ -1846,11 +1894,12 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 TUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedelta64](
 datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"T
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*VT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
-@Union[pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
+RUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp$
 numpy.datetime64"numpy.datetime640:typing.overloadX
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"J
@@ -2377,7 +2426,7 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 resolution3pandas._libs.tslibs.timedeltas.Timedelta.resolutionT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltarU
 value.pandas._libs.tslibs.timedeltas.Timedelta.value
-builtins.int"builtins.intю
+builtins.int"builtins.int
 	Timestamp(pandas._libs.tslibs.timestamps.Timestamp"datetime.datetime*
 __new__0pandas._libs.tslibs.timestamps.Timestamp.__new__"
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
@@ -2574,12 +2623,14 @@ nanosecond3pandas._libs.tslibs.timestamps.Timestamp.nanosecond"
 cls
 3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
-combine0pandas._libs.tslibs.timestamps.Timestamp.combine"&
-datetime.datetime"datetime.datetime*
-cls
-.Type[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"type*(
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
+combine0pandas._libs.tslibs.timestamps.Timestamp.combine"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+cls
+3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type*(
 date
 
datetime.date"
datetime.date*(
 time
@@ -2762,13 +2813,9 @@ astimezone3pandas._libs.tslibs.timestamps.Timestamp.astimezone"
 isoweekday3pandas._libs.tslibs.timestamps.Timestamp.isoweekday"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
-isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
-8TypeAlias[Tuple[builtins.int,builtins.int,builtins.int]]
--Tuple[builtins.int,builtins.int,builtins.int]
-builtins.int"builtins.int
-builtins.int"builtins.int
-builtins.int"builtins.int"/pandas._libs.tslibs.timestamps._IsoCalendarDate*^
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
+isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
+Any*^
 selfT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
 is_leap_year5pandas._libs.tslibs.timestamps.Timestamp.is_leap_year"
@@ -3022,7 +3069,39 @@ weekofyear3pandas._libs.tslibs.timestamps.Timestamp.weekofyear"
 daysinmonth4pandas._libs.tslibs.timestamps.Timestamp.daysinmonth"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`2
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+unit-pandas._libs.tslibs.timestamps.Timestamp.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*^
+selfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+as_unit0pandas._libs.tslibs.timestamps.Timestamp.as_unit"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+self
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool 2
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__"
 
builtins.bool"
builtins.bool*VT
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.nattype.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.nattype.protobuf
index 2733a7d535..c1daf2c125 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.nattype.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.nattype.protobuf
@@ -45,8 +45,12 @@ pUnion[datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,nu
 datetime.timedelta"datetime.timedeltaF
 !pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period$
 numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64"/pandas._libs.tslibs.nattype._NaTComparisonTypes^
+numpy.timedelta64"numpy.timedelta64"/pandas._libs.tslibs.nattype._NaTComparisonTypesk
 NaTType#pandas._libs.tslibs.nattype.NaTType"builtins.object*
+__hash__,pandas._libs.tslibs.nattype.NaTType.__hash__"
+builtins.int"builtins.int*T
+selfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*
 asm8(pandas._libs.tslibs.nattype.NaTType.asm8"$
 numpy.datetime64"numpy.datetime64*T
 selfJ
@@ -306,7 +310,39 @@ nanosecond.pandas._libs.tslibs.nattype.NaTType.nanosecond"
 __ne__*pandas._libs.tslibs.nattype.NaTType.__ne__"
 
builtins.bool"
builtins.bool*LJ
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*$"
-builtins.object"builtins.objectr
+builtins.object"builtins.object*
+unit(pandas._libs.tslibs.nattype.NaTType.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*T
+selfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:builtins.property`*
+as_unit+pandas._libs.tslibs.nattype.NaTType.as_unit"
+(pandas._libs.tslibs.nattype.NaTType.SelfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType(*
+self
+(pandas._libs.tslibs.nattype.NaTType.SelfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool r
 value)pandas._libs.tslibs.nattype.NaTType.value
 4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
 )numpy.signedinteger[numpy._typing._64Bit],
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.offsets.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.offsets.protobuf
index 627dd99b96..f0b1119875 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.offsets.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.offsets.protobuf
@@ -296,8 +296,21 @@ __reduce__>pandas._libs.tslibs.offsets.SingleConstructorOffset.__reduce__*
 	normalize
 
builtins.bool"
builtins.bool *6
 offset(
-datetime.timedelta"datetime.timedelta a
-BusinessDay'pandas._libs.tslibs.offsets.BusinessDay")pandas._libs.tslibs.offsets.BusinessMixin
+datetime.timedelta"datetime.timedelta 
+BusinessDay'pandas._libs.tslibs.offsets.BusinessDay"&pandas._libs.tslibs.offsets.BaseOffset*
+__init__0pandas._libs.tslibs.offsets.BusinessDay.__init__"
+None*\
+selfR
+'pandas._libs.tslibs.offsets.BusinessDay"'pandas._libs.tslibs.offsets.BusinessDay*%
+n
+builtins.int"builtins.int */
+	normalize
+
builtins.bool"
builtins.bool *6
+offset(
+datetime.timedelta"datetime.timedelta *J
+
+__reduce__2pandas._libs.tslibs.offsets.BusinessDay.__reduce__*
+self
 BusinessHour(pandas._libs.tslibs.offsets.BusinessHour")pandas._libs.tslibs.offsets.BusinessMixin*
 __init__1pandas._libs.tslibs.offsets.BusinessHour.__init__"
 None*^
@@ -516,9 +529,9 @@ VUnion[builtins.str,datetime.time,typing.Collection[Union[builtins.str,datetime.
 Any"
builtins.list
 None ~
 CustomBusinessMonthEnd2pandas._libs.tslibs.offsets.CustomBusinessMonthEnd"0pandas._libs.tslibs.offsets._CustomBusinessMonth
-CustomBusinessMonthBegin4pandas._libs.tslibs.offsets.CustomBusinessMonthBegin"0pandas._libs.tslibs.offsets._CustomBusinessMonth	
+CustomBusinessMonthBegin4pandas._libs.tslibs.offsets.CustomBusinessMonthBegin"0pandas._libs.tslibs.offsets._CustomBusinessMonth	
 
-DateOffset&pandas._libs.tslibs.offsets.DateOffset"/pandas._libs.tslibs.offsets.RelativeDeltaOffset*
+DateOffset&pandas._libs.tslibs.offsets.DateOffset"/pandas._libs.tslibs.offsets.RelativeDeltaOffset*
 __init__/pandas._libs.tslibs.offsets.DateOffset.__init__"
 None*Z
 selfP
@@ -552,9 +565,11 @@ DateOffset&pandas._libs.tslibs.offsets.DateOffset"/pandas._libs.tslibs.offsets.
 month
 builtins.int"builtins.int *'
 day
-builtins.int"builtins.int *+
-weekday
-builtins.int"builtins.int *(
+builtins.int"builtins.int *Q
+weekdayB
+Union[builtins.int,Any]
+builtins.int"builtins.int
+Any *(
 hour
 builtins.int"builtins.int **
 minute
@@ -617,7 +632,9 @@ MUnion[datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,builtins.str]
 __annotations__+pandas._libs.tslibs.offsets.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict*
+Any"
builtins.dict*A
+WeekdayClass(pandas._libs.tslibs.offsets.WeekdayClass
+Any*
 npnumpy *
 prefix_mapping*pandas._libs.tslibs.offsets.prefix_mappingx
 )builtins.dict[builtins.str,builtins.type]
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.protobuf
index 38a134cb6b..46bdfd5ac9 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.protobuf
@@ -1,6 +1,10 @@
 
-pandas._libs.tslibs^
+pandas._libs.tslibsk
 NaTType#pandas._libs.tslibs.nattype.NaTType"builtins.object*
+__hash__,pandas._libs.tslibs.nattype.NaTType.__hash__"
+builtins.int"builtins.int*T
+selfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*
 asm8(pandas._libs.tslibs.nattype.NaTType.asm8"$
 numpy.datetime64"numpy.datetime64*T
 selfJ
@@ -260,7 +264,39 @@ nanosecond.pandas._libs.tslibs.nattype.NaTType.nanosecond"
 __ne__*pandas._libs.tslibs.nattype.NaTType.__ne__"
 
builtins.bool"
builtins.bool*LJ
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*$"
-builtins.object"builtins.objectr
+builtins.object"builtins.object*
+unit(pandas._libs.tslibs.nattype.NaTType.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*T
+selfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:builtins.property`*
+as_unit+pandas._libs.tslibs.nattype.NaTType.as_unit"
+(pandas._libs.tslibs.nattype.NaTType.SelfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType(*
+self
+(pandas._libs.tslibs.nattype.NaTType.SelfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool r
 value)pandas._libs.tslibs.nattype.NaTType.value
 4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
 )numpy.signedinteger[numpy._typing._64Bit],
@@ -969,8 +1005,8 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 __radd__*pandas._libs.tslibs.period.Period.__radd__"J
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*HF
 !pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*LJ
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
-	Timedelta(pandas._libs.tslibs.timedeltas.Timedelta"datetime.timedelta*5
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
+	Timedelta(pandas._libs.tslibs.timedeltas.Timedelta"datetime.timedelta*-
 __new__0pandas._libs.tslibs.timedeltas.Timedelta.__new__"
 -pandas._libs.tslibs.timedeltas.Timedelta.SelfT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
@@ -984,30 +1020,10 @@ nUnion[builtins.str,builtins.int,pandas._libs.tslibs.timedeltas.Timedelta,dateti
 builtins.int"builtins.intT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
 datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64 *#
-unit#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+numpy.timedelta64"numpy.timedelta64 *
+unit
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -1265,7 +1281,39 @@ aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[T
 builtins.list[Any]
 Any"
builtins.listM
 TypeAlias[TypedDict]
-	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike 2+
+	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike *
+unit-pandas._libs.tslibs.timedeltas.Timedelta.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*^
+selfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta0:builtins.property`*
+as_unit0pandas._libs.tslibs.timedeltas.Timedelta.as_unit"
+-pandas._libs.tslibs.timedeltas.Timedelta.SelfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
+self
+-pandas._libs.tslibs.timedeltas.Timedelta.SelfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool 2+
 __add__0pandas._libs.tslibs.timedeltas.Timedelta.__add__
 __add__0pandas._libs.tslibs.timedeltas.Timedelta.__add__"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*VT
@@ -1429,7 +1477,7 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 mUnion[pandas.core.series.TimedeltaSeries,pandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]]H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries
 Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series0:typing.overloadX2$
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series0:typing.overloadX2$
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*VT
@@ -1437,11 +1485,12 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 TUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedelta64](
 datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"T
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*VT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
-@Union[pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
+RUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp$
 numpy.datetime64"numpy.datetime640:typing.overloadX
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"J
@@ -1968,7 +2017,7 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 resolution3pandas._libs.tslibs.timedeltas.Timedelta.resolutionT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltarU
 value.pandas._libs.tslibs.timedeltas.Timedelta.value
-builtins.int"builtins.intю
+builtins.int"builtins.int
 	Timestamp(pandas._libs.tslibs.timestamps.Timestamp"datetime.datetime*
 __new__0pandas._libs.tslibs.timestamps.Timestamp.__new__"
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
@@ -2165,12 +2214,14 @@ nanosecond3pandas._libs.tslibs.timestamps.Timestamp.nanosecond"
 cls
 3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
-combine0pandas._libs.tslibs.timestamps.Timestamp.combine"&
-datetime.datetime"datetime.datetime*
-cls
-.Type[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"type*(
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
+combine0pandas._libs.tslibs.timestamps.Timestamp.combine"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+cls
+3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type*(
 date
 
datetime.date"
datetime.date*(
 time
@@ -2353,13 +2404,9 @@ astimezone3pandas._libs.tslibs.timestamps.Timestamp.astimezone"
 isoweekday3pandas._libs.tslibs.timestamps.Timestamp.isoweekday"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
-isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
-8TypeAlias[Tuple[builtins.int,builtins.int,builtins.int]]
--Tuple[builtins.int,builtins.int,builtins.int]
-builtins.int"builtins.int
-builtins.int"builtins.int
-builtins.int"builtins.int"/pandas._libs.tslibs.timestamps._IsoCalendarDate*^
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
+isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
+Any*^
 selfT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
 is_leap_year5pandas._libs.tslibs.timestamps.Timestamp.is_leap_year"
@@ -2613,7 +2660,39 @@ weekofyear3pandas._libs.tslibs.timestamps.Timestamp.weekofyear"
 daysinmonth4pandas._libs.tslibs.timestamps.Timestamp.daysinmonth"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`2
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+unit-pandas._libs.tslibs.timestamps.Timestamp.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*^
+selfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+as_unit0pandas._libs.tslibs.timestamps.Timestamp.as_unit"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+self
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool 2
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__"
 
builtins.bool"
builtins.bool*VT
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.timedeltas.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.timedeltas.protobuf
index 2c78a8af36..ffa0abc81b 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.timedeltas.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.timedeltas.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.timestamps.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.timestamps.protobuf
index d16a979a51..d0cef1c787 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.timestamps.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._libs.tslibs.timestamps.protobuf
@@ -354,7 +354,7 @@ resolutiondatetime.time.resolution(
 datetime.datetime"datetime.datetime*,
 self"
 datetime.tzinfo"datetime.tzinfo*(&
-datetime.datetime"datetime.datetimeю
+datetime.datetime"datetime.datetime
 	Timestamp(pandas._libs.tslibs.timestamps.Timestamp"datetime.datetime*
 __new__0pandas._libs.tslibs.timestamps.Timestamp.__new__"
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
@@ -551,12 +551,14 @@ nanosecond3pandas._libs.tslibs.timestamps.Timestamp.nanosecond"
 cls
 3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
-combine0pandas._libs.tslibs.timestamps.Timestamp.combine"&
-datetime.datetime"datetime.datetime*
-cls
-.Type[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"type*(
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
+combine0pandas._libs.tslibs.timestamps.Timestamp.combine"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+cls
+3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type*(
 date
 
datetime.date"
datetime.date*(
 time
@@ -739,13 +741,9 @@ astimezone3pandas._libs.tslibs.timestamps.Timestamp.astimezone"
 isoweekday3pandas._libs.tslibs.timestamps.Timestamp.isoweekday"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
-isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
-8TypeAlias[Tuple[builtins.int,builtins.int,builtins.int]]
--Tuple[builtins.int,builtins.int,builtins.int]
-builtins.int"builtins.int
-builtins.int"builtins.int
-builtins.int"builtins.int"/pandas._libs.tslibs.timestamps._IsoCalendarDate*^
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
+isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
+Any*^
 selfT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
 is_leap_year5pandas._libs.tslibs.timestamps.Timestamp.is_leap_year"
@@ -999,7 +997,39 @@ weekofyear3pandas._libs.tslibs.timestamps.Timestamp.weekofyear"
 daysinmonth4pandas._libs.tslibs.timestamps.Timestamp.daysinmonth"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`2
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+unit-pandas._libs.tslibs.timestamps.Timestamp.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*^
+selfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+as_unit0pandas._libs.tslibs.timestamps.Timestamp.as_unit"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+self
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool 2
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__"
 
builtins.bool"
builtins.bool*VT
@@ -1310,5 +1340,7 @@ resolution3pandas._libs.tslibs.timestamps.Timestamp.resolutionT
 __annotations__.pandas._libs.tslibs.timestamps.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict*
+Any"
builtins.dict*L
+_IsoCalendarDate/pandas._libs.tslibs.timestamps._IsoCalendarDate
+Any*
 npnumpy 
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._testing.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._testing.protobuf
index 1afb0406b0..19459a4ac5 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._testing.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._testing.protobuf
@@ -1,30 +1,36 @@
 
-pandas._testing.
-
getSeriesDatapandas._testing.getSeriesData
-assert_almost_equal#pandas._testing.assert_almost_equal"
-Any*
-left
-Any*
-right
-Any*v
-check_dtypec
-!Union[builtins.bool,builtins.str]
-
builtins.bool"
builtins.bool
-builtins.str"builtins.str *}
-check_less_precisec
-!Union[builtins.bool,builtins.int]
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int *
+pandas._testing
+assert_almost_equal#pandas._testing.assert_almost_equal"
+None*S
+leftI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*T
+rightI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*
+check_dtype
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
+builtins.str"builtins.str *,
+rtol 
+builtins.float"builtins.float *,
+atol 
+builtins.float"builtins.float *
 kwargs
-Any
-assert_dict_equal!pandas._testing.assert_dict_equal"
-Any*
-left
-Any*
-right
-Any*2
+Any
+assert_dict_equal!pandas._testing.assert_dict_equal"
+None*C
+left9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict*D
+right9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict*2
 compare_keys
-
builtins.bool"
builtins.bool 
+
builtins.bool"
builtins.bool 
 assert_index_equal"pandas._testing.assert_index_equal"
 None*X
 leftN
@@ -32,113 +38,193 @@
 Any"pandas.core.indexes.base.Index*Y
 rightN
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index
-assert_class_equal"pandas._testing.assert_class_equal"
-Any*
-left
-Any*
-right
-Any*p
-exactc
-!Union[builtins.bool,builtins.str]
-
builtins.bool"
builtins.bool
-builtins.str"builtins.str *
-obj
-Any 
-assert_attr_equal!pandas._testing.assert_attr_equal"
-Any*
-attr
-Any*
-left
-Any*
-right
-Any*'
+Any"pandas.core.indexes.base.Index*
+exact
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
+builtins.str"builtins.str *1
+check_names
+
builtins.bool"
builtins.bool *1
+check_exact
+
builtins.bool"
builtins.bool *7
+check_categorical
+
builtins.bool"
builtins.bool *1
+check_order
+
builtins.bool"
builtins.bool *,
+rtol 
+builtins.float"builtins.float *,
+atol 
+builtins.float"builtins.float *'
+obj
+builtins.str"builtins.str 
+assert_class_equal"pandas._testing.assert_class_equal"
+None*S
+leftI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*T
+rightI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*
+exact
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
+builtins.str"builtins.str *'
 obj
-builtins.str"builtins.str u
+builtins.str"builtins.str 
+assert_attr_equal!pandas._testing.assert_attr_equal"
+None*&
+attr
+builtins.str"builtins.str*,
+left"
+builtins.object"builtins.object*-
+right"
+builtins.object"builtins.object*'
+obj
+builtins.str"builtins.str 
 "assert_is_valid_plot_return_object2pandas._testing.assert_is_valid_plot_return_object"
-None*
-objs
-AnyP
+None*
+objs
+kUnion[pandas.core.series.Series[Any],numpy.ndarray[Any,Any],Any,builtins.tuple[Any],builtins.dict[Any,Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+Any.
+builtins.tuple[Any]
+Any"builtins.tuple9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
 assert_is_sorted pandas._testing.assert_is_sorted"
-None*
-seq
-Any
+None*
+seq
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike
 assert_categorical_equal(pandas._testing.assert_categorical_equal"
-None*
-left
-Any*
-right
-Any*1
+None*b
+leftX
+*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*c
+rightX
+*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*1
 check_dtype
 
builtins.bool"
builtins.bool *:
 check_category_order
 
builtins.bool"
builtins.bool *'
 obj
-builtins.str"builtins.str 
+builtins.str"builtins.str 
 assert_interval_array_equal+pandas._testing.assert_interval_array_equal"
-None*
-left
-Any*
-right
-Any*)
-exact
+None*`
+leftV
+)pandas.core.arrays.interval.IntervalArray")pandas.core.arrays.interval.IntervalArray*a
+rightV
+)pandas.core.arrays.interval.IntervalArray")pandas.core.arrays.interval.IntervalArray*
+exact
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
 builtins.str"builtins.str *'
 obj
-builtins.str"builtins.str 
+builtins.str"builtins.str 
 assert_period_array_equal)pandas._testing.assert_period_array_equal"
-None*
-left
-Any*
-right
-Any*'
+None*X
+leftN
+%pandas.core.arrays.period.PeriodArray"%pandas.core.arrays.period.PeriodArray*Y
+rightN
+%pandas.core.arrays.period.PeriodArray"%pandas.core.arrays.period.PeriodArray*'
 obj
-builtins.str"builtins.str 
+builtins.str"builtins.str 
 assert_datetime_array_equal+pandas._testing.assert_datetime_array_equal"
-None*
-left
-Any*
-right
-Any*'
-obj
-builtins.str"builtins.str 
+None*b
+leftX
+*pandas.core.arrays.datetimes.DatetimeArray"*pandas.core.arrays.datetimes.DatetimeArray*c
+rightX
+*pandas.core.arrays.datetimes.DatetimeArray"*pandas.core.arrays.datetimes.DatetimeArray*0
+
+check_freq
+
builtins.bool"
builtins.bool 
 assert_timedelta_array_equal,pandas._testing.assert_timedelta_array_equal"
+None*f
+left\
+,pandas.core.arrays.timedeltas.TimedeltaArray",pandas.core.arrays.timedeltas.TimedeltaArray*g
+right\
+,pandas.core.arrays.timedeltas.TimedeltaArray",pandas.core.arrays.timedeltas.TimedeltaArray*0
+
+check_freq
+
builtins.bool"
builtins.bool 
+assert_numpy_array_equal(pandas._testing.assert_numpy_array_equal"
 None*
 left
 Any*
 right
-Any*'
-obj
-builtins.str"builtins.str 
-assert_numpy_array_equal(pandas._testing.assert_numpy_array_equal"
-Any*
-left
-Any*
-right
 Any*0
 
 strict_nan
-
builtins.bool"
builtins.bool *1
-check_dtype
-
builtins.bool"
builtins.bool *
-err_msg
-Any *
+
builtins.bool"
builtins.bool *
+check_dtype
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
+builtins.str"builtins.str *S
+err_msgD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *
 
-check_same
-Any *'
+check_same
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *'
 obj
-builtins.str"builtins.str 
+builtins.str"builtins.str *
+index_values
+FUnion[pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],None]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+None 
 assert_extension_array_equal,pandas._testing.assert_extension_array_equal"
-None*
-left
-Any*
-right
-Any*1
-check_dtype
-
builtins.bool"
builtins.bool *8
-check_less_precise
-
builtins.bool"
builtins.bool *1
+None*Z
+leftP
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*[
+rightP
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
+check_dtype
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+index_values
+FUnion[pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],None]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+None *1
 check_exact
-
builtins.bool"
builtins.bool 
+
builtins.bool"
builtins.bool *,
+rtol 
+builtins.float"builtins.float *,
+atol 
+builtins.float"builtins.float *'
+obj
+builtins.str"builtins.str 
+
 assert_frame_equal"pandas._testing.assert_frame_equal"
 None*D
 left:
@@ -161,10 +247,6 @@ check_same
 Literal[builtins.str]	
 builtins.str"builtins.str *6
 check_frame_type
-
builtins.bool"
builtins.bool *}
-check_less_precisec
-!Union[builtins.int,builtins.bool]
-builtins.int"builtins.int
 
builtins.bool"
builtins.bool *1
 check_names
 
builtins.bool"
builtins.bool */
@@ -181,9 +263,8 @@ check_like
 
builtins.bool"
builtins.bool *0
 
 check_freq
-
builtins.bool"
builtins.bool *0
-
-check_flag
+
builtins.bool"
builtins.bool *1
+check_flags
 
builtins.bool"
builtins.bool *,
 rtol 
 builtins.float"builtins.float *,
@@ -198,49 +279,74 @@ check_flag
 right
 Any*
 kwargs
-Any
+Any
 assert_sp_array_equal%pandas._testing.assert_sp_array_equal"
-None*
-left
-Any*
-right
-Any*1
-check_dtype
-
builtins.bool"
builtins.bool *0
-
-check_kind
-
builtins.bool"
builtins.bool *6
-check_fill_value
-
builtins.bool"
builtins.bool *?
-consolidate_block_indices
-
builtins.bool"
builtins.bool m
+None*d
+leftZ
++pandas.core.arrays.sparse.array.SparseArray"+pandas.core.arrays.sparse.array.SparseArray*e
+rightZ
++pandas.core.arrays.sparse.array.SparseArray"+pandas.core.arrays.sparse.array.SparseArray
 assert_contains_all#pandas._testing.assert_contains_all"
-None*
-iterable
-Any*
-dic
-Anyu
+None*
+iterable
+!typing.Iterable[pandas._typing.T]I
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object"typing.Iterable*
+dic
+"typing.Container[pandas._typing.T]I
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object"typing.Container
 assert_copypandas._testing.assert_copy"
-None*
-iter1
-Any*
-iter2
-Any*
+None*
+iter1
+!typing.Iterable[pandas._typing.T]I
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object"typing.Iterable*
+iter2
+!typing.Iterable[pandas._typing.T]I
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object"typing.Iterable*
 
 eql_kwargs
-Any
-assert_produces_warning'pandas._testing.assert_produces_warning"
-None*
-expected_warning
-Any *0
-filter_level
-builtins.str"builtins.str *
-clear
-Any *6
+Any
+assert_produces_warning'pandas._testing.assert_produces_warning"
+Btyping.Generator[builtins.list[warnings.WarningMessage],None,None]k
+&builtins.list[warnings.WarningMessage]2
+warnings.WarningMessage"warnings.WarningMessage"
builtins.list
+None
+None"typing.Generator*
+expected_warning
+`Union[Type[builtins.Warning],Literal[builtins.bool],builtins.tuple[Type[builtins.Warning]],None]F
+Type[builtins.Warning]$
+builtins.Warning"builtins.Warning"type:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool
+&builtins.tuple[Type[builtins.Warning]]F
+Type[builtins.Warning]$
+builtins.Warning"builtins.Warning"type"builtins.tuple
+None *
+filter_level
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *6
 check_stacklevel
 
builtins.bool"
builtins.bool *=
 raise_on_extra_warnings
-
builtins.bool"
builtins.bool 
+
builtins.bool"
builtins.bool *Q
+matchD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None 0:contextlib.contextmanager
 ensure_cleanpandas._testing.ensure_clean"n
 (typing.Generator[builtins.str,None,None]
 builtins.str"builtins.str
@@ -253,8 +359,9 @@ eql_kwargs
 return_filelike
 
builtins.bool"
builtins.bool *
 kwargs
-Any0:contextlib.contextmanager"
-assert_series_equal#pandas._testing.assert_series_equal	
+Any0:contextlib.contextmanager"
+assert_series_equal#pandas._testing.assert_series_equal
+
 assert_series_equal#pandas._testing.assert_series_equal"
 None*N
 leftD
@@ -262,12 +369,16 @@ eql_kwargs
 Any"pandas.core.series.Series*O
 rightD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*1
-check_dtype
-
builtins.bool"
builtins.bool *{
-check_index_typec
-!Union[builtins.bool,builtins.str]
-
builtins.bool"
builtins.bool
+Any"pandas.core.series.Series*
+check_dtype
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+check_index_type
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
 builtins.str"builtins.str *7
 check_series_type
 
builtins.bool"
builtins.bool *1
@@ -298,7 +409,7 @@ check_freq
 
 check_like:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX	
 assert_series_equal#pandas._testing.assert_series_equal"
 None*N
 leftD
@@ -306,12 +417,16 @@ check_like:
 Any"pandas.core.series.Series*O
 rightD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*1
-check_dtype
-
builtins.bool"
builtins.bool *{
-check_index_typec
-!Union[builtins.bool,builtins.str]
-
builtins.bool"
builtins.bool
+Any"pandas.core.series.Series*
+check_dtype
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+check_index_type
+*Union[builtins.bool,Literal[builtins.str]]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
 builtins.str"builtins.str *7
 check_series_type
 
builtins.bool"
builtins.bool *1
@@ -348,4 +463,7 @@ check_like
 __annotations__pandas._testing.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict
\ No newline at end of file
+Any"
builtins.dict*)
+Artistpandas._testing.Artist
+Any*
+npnumpy 
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._typing.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._typing.protobuf
index c53d4ef821..4926e55977 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._typing.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas._typing.protobuf
@@ -211,16 +211,70 @@ ReadBufferpandas._typing.ReadBuffer"pandas._typing.BaseBuffer*
 self
 7pandas._typing.ReadCsvBuffer[pandas._typing.AnyStr_cov]R
 pandas._typing.AnyStr_cov"
-builtins.object"builtins.object"builtins.object"pandas._typing.ReadCsvBuffer0:builtins.property`PX
-WriteExcelBufferpandas._typing.WriteExcelBuffer"pandas._typing.WriteBuffer*
+builtins.object"builtins.object"builtins.object"pandas._typing.ReadCsvBuffer0:builtins.property`PX
+WriteExcelBufferpandas._typing.WriteExcelBuffer"pandas._typing.WriteBuffer*
 truncate(pandas._typing.WriteExcelBuffer.truncate"
-builtins.int"builtins.int*L
-selfB
-pandas._typing.WriteExcelBuffer"pandas._typing.WriteExcelBuffer*P
-sizeD
+builtins.int"builtins.int*DB
+pandas._typing.WriteExcelBuffer"pandas._typing.WriteExcelBuffer*HD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None XP
+None X
+SequenceNotStrpandas._typing.SequenceNotStr"builtins.object*
+__contains__*pandas._typing.SequenceNotStr.__contains__"
+
builtins.bool"
builtins.bool*
+3pandas._typing.SequenceNotStr[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"pandas._typing.SequenceNotStr*$"
+builtins.object"builtins.object*
+__len__%pandas._typing.SequenceNotStr.__len__"
+builtins.int"builtins.int*
+3pandas._typing.SequenceNotStr[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"pandas._typing.SequenceNotStr*
+__iter__&pandas._typing.SequenceNotStr.__iter__"
+%typing.Iterator[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"typing.Iterator*
+3pandas._typing.SequenceNotStr[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"pandas._typing.SequenceNotStr*
+index#pandas._typing.SequenceNotStr.index"
+builtins.int"builtins.int*
+3pandas._typing.SequenceNotStr[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"pandas._typing.SequenceNotStr*	
+Any* 
+builtins.int"builtins.int * 
+builtins.int"builtins.int *
+count#pandas._typing.SequenceNotStr.count"
+builtins.int"builtins.int*
+3pandas._typing.SequenceNotStr[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"pandas._typing.SequenceNotStr*	
+Any*
+__reversed__*pandas._typing.SequenceNotStr.__reversed__"
+%typing.Iterator[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"typing.Iterator*
+3pandas._typing.SequenceNotStr[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"pandas._typing.SequenceNotStr2
+__getitem__)pandas._typing.SequenceNotStr.__getitem__
+__getitem__)pandas._typing.SequenceNotStr.__getitem__"M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object*
+3pandas._typing.SequenceNotStr[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"pandas._typing.SequenceNotStr*.,
+typing.SupportsIndex"typing.SupportsIndex0:typing.overloadX
+__getitem__)pandas._typing.SequenceNotStr.__getitem__"
+%typing.Sequence[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"typing.Sequence*
+3pandas._typing.SequenceNotStr[pandas._typing._T_co]M
+pandas._typing._T_co"
+builtins.object"builtins.object"builtins.object"pandas._typing.SequenceNotStr*" 
+builtins.slice"builtins.slice0:typing.overloadXPXP
 _WindowingNumbaKwargs$pandas._typing._WindowingNumbaKwargs"typing._TypedDictD
 StyleExportDictpandas._typing.StyleExportDict"typing._TypedDict*
 __annotations__pandas._typing.__annotations__W
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.api.extensions.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.api.extensions.protobuf
index b304843da4..af0ef04714 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.api.extensions.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.api.extensions.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.api.types.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.api.types.protobuf
index 2dc80e1b86..7ec7a86079 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.api.types.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.api.types.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.arrays.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.arrays.protobuf
index 3425caa591..5204199005 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.arrays.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.arrays.protobuf
@@ -54,7 +54,7 @@
 skipna
 
builtins.bool"
builtins.bool *
 kwargs
-Any
+Any
 Categorical*pandas.core.arrays.categorical.Categorical"&pandas.core.arrays.base.ExtensionArray*
 __init__3pandas.core.arrays.categorical.Categorical.__init__"
 None*b
@@ -121,10 +121,6 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 size/pandas.core.arrays.categorical.Categorical.size"
 builtins.int"builtins.int*b
 selfX
-*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*
-itemsize3pandas.core.arrays.categorical.Categorical.itemsize"
-builtins.int"builtins.int*b
-selfX
 *pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*
 tolist1pandas.core.arrays.categorical.Categorical.tolist"
 builtins.list[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
@@ -197,6 +193,50 @@ as_ordered5pandas.core.arrays.categorical.Categorical.as_ordered"X
 as_unordered7pandas.core.arrays.categorical.Categorical.as_unordered"X
 *pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*b
 selfX
+*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*
+set_categories9pandas.core.arrays.categorical.Categorical.set_categories"X
+*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*b
+selfX
+*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*
+new_categories
+Any*V
+orderedG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+rename
+
builtins.bool"
builtins.bool *
+rename_categories
-dtype+pandas.core.arrays.period.PeriodArray.dtype*
-self*
+
builtins.bool"
builtins.bool *
+dtype+pandas.core.arrays.period.PeriodArray.dtype"N
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype*X
+selfN
+%pandas.core.arrays.period.PeriodArray"%pandas.core.arrays.period.PeriodArray0:builtins.property`*
 	__array__/pandas.core.arrays.period.PeriodArray.__array__"9
 numpy.ndarray[Any,Any]
 Any
@@ -1196,7 +1023,7 @@ weekofyear0pandas.core.arrays.period.PeriodArray.weekofyear
 
days_in_month3pandas.core.arrays.period.PeriodArray.days_in_month
 builtins.int"builtins.intr^
 daysinmonth1pandas.core.arrays.period.PeriodArray.daysinmonth
-builtins.int"builtins.int;
+builtins.int"builtins.int+
 SparseArray+pandas.core.arrays.sparse.array.SparseArray"&pandas.core.arrays.base.ExtensionArray")pandas.core.arrays.base.ExtensionOpsMixin*
 __init__4pandas.core.arrays.sparse.array.SparseArray.__init__"
 None*d
@@ -1273,61 +1100,14 @@ fill_value
 fill_value
 Any *F
 unique2pandas.core.arrays.sparse.array.SparseArray.unique*
-self*
-	factorize5pandas.core.arrays.sparse.array.SparseArray.factorize"
-ITuple[numpy.ndarray[Any,Any],pandas.core.arrays.sparse.array.SparseArray]9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayZ
-+pandas.core.arrays.sparse.array.SparseArray"+pandas.core.arrays.sparse.array.SparseArray*d
-selfZ
-+pandas.core.arrays.sparse.array.SparseArray"+pandas.core.arrays.sparse.array.SparseArray*/
-na_sentinel
-builtins.int"builtins.int *5
-use_na_sentinel
-
builtins.bool"
builtins.bool *
+self*
 value_counts8pandas.core.arrays.sparse.array.SparseArray.value_counts"
 Any*d
 selfZ
 +pandas.core.arrays.sparse.array.SparseArray"+pandas.core.arrays.sparse.array.SparseArray*,
 dropna
 
builtins.bool"
builtins.bool *J
-__getitem__7pandas.core.arrays.sparse.array.SparseArray.__getitem__***
-
-take0pandas.core.arrays.sparse.array.SparseArray.take"Z
-+pandas.core.arrays.sparse.array.SparseArray"+pandas.core.arrays.sparse.array.SparseArray*d
-selfZ
-+pandas.core.arrays.sparse.array.SparseArray"+pandas.core.arrays.sparse.array.SparseArray*
-indices
-TypeAlias[Union[typing.Sequence[builtins.int],typing.Sequence[numpy.integer[Any]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
-Union[typing.Sequence[builtins.int],typing.Sequence[numpy.integer[Any]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]N
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequenced
-#typing.Sequence[numpy.integer[Any]],
-numpy.integer[Any]
-Any"
numpy.integer"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.TakeIndexer*0
-
-allow_fill
-
builtins.bool"
builtins.bool *
-
-fill_value
-Any *
-searchsorted8pandas.core.arrays.sparse.array.SparseArray.searchsorted"
-Any*d
-selfZ
-+pandas.core.arrays.sparse.array.SparseArray"+pandas.core.arrays.sparse.array.SparseArray*
-v
-Any*(
-side
-builtins.str"builtins.str *
-sorter
-Any *B
+__getitem__7pandas.core.arrays.sparse.array.SparseArray.__getitem__***B
 copy0pandas.core.arrays.sparse.array.SparseArray.copy*
 self*
 astype2pandas.core.arrays.sparse.array.SparseArray.astype"
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.algorithms.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.algorithms.protobuf
index 82c109d869..00f9438c8f 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.algorithms.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.algorithms.protobuf
@@ -59,7 +59,7 @@ allow_fill
 
builtins.bool"
builtins.bool *
 
 fill_value
-Any "
+Any "
 uniquepandas.core.algorithms.unique
 uniquepandas.core.algorithms.unique"P
 &pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*\
@@ -100,23 +100,20 @@ DUnion[numpy.ndarray[Any,Any],pandas.core.arrays.base.ExtensionArray]9
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*P
 valuesD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series0:typing.overloadX
+Any"pandas.core.series.Series0:typing.overloadX
 uniquepandas.core.algorithms.unique"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-values
-0Union[numpy.ndarray[Any,Any],builtins.list[Any]]9
+Any"
numpy.ndarray*E
+values9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray,
-builtins.list[Any]
-Any"
builtins.list0:typing.overloadX
+Any"
numpy.ndarray0:typing.overloadX
 uniquepandas.core.algorithms.unique"P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*\
 valuesP
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray0:typing.overloadX"
-	factorize pandas.core.algorithms.factorize
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray0:typing.overloadX"
+	factorize pandas.core.algorithms.factorize
 	factorize pandas.core.algorithms.factorize"
 4Tuple[numpy.ndarray[Any,Any],numpy.ndarray[Any,Any]]9
 numpy.ndarray[Any,Any]
@@ -124,14 +121,11 @@ DUnion[numpy.ndarray[Any,Any],pandas.core.arrays.base.ExtensionArray]9
 Any"
numpy.ndarray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-values
-3Union[typing.Sequence[Any],numpy.recarray[Any,Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence;
-numpy.recarray[Any,Any]
+Any"
numpy.ndarray*E
+values9
+numpy.ndarray[Any,Any]
 Any
-Any"numpy.recarray**
+Any"
numpy.ndarray**
 sort
 
builtins.bool"
builtins.bool *5
 use_na_sentinel
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.api.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.api.protobuf
index aad74f3a33..823d80b52a 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.api.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.api.protobuf
@@ -1,5 +1,5 @@
 
-pandas.core.api
+pandas.core.api
 Categorical*pandas.core.arrays.categorical.Categorical"&pandas.core.arrays.base.ExtensionArray*
 __init__3pandas.core.arrays.categorical.Categorical.__init__"
 None*b
@@ -66,10 +66,6 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 size/pandas.core.arrays.categorical.Categorical.size"
 builtins.int"builtins.int*b
 selfX
-*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*
-itemsize3pandas.core.arrays.categorical.Categorical.itemsize"
-builtins.int"builtins.int*b
-selfX
 *pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*
 tolist1pandas.core.arrays.categorical.Categorical.tolist"
 builtins.list[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
@@ -142,6 +138,50 @@ as_ordered5pandas.core.arrays.categorical.Categorical.as_ordered"X
 as_unordered7pandas.core.arrays.categorical.Categorical.as_unordered"X
 *pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*b
 selfX
+*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*
+set_categories9pandas.core.arrays.categorical.Categorical.set_categories"X
+*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*b
+selfX
+*pandas.core.arrays.categorical.Categorical"*pandas.core.arrays.categorical.Categorical*
+new_categories
+Any*V
+orderedG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+rename
+
builtins.bool"
builtins.bool *
+rename_categoriesUnion[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
-typing.Hashable"typing.Hashable
-'builtins.list[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX
-reset_index'pandas.core.frame.DataFrame.reset_index":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-level
-NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level-
-typing.Sequence[Unknown]"typing.Sequence *q
-	col_level`
- Union[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str *2
-col_fill"
-typing.Hashable"typing.Hashable **
-drop
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *6
-allow_duplicates
-
builtins.bool"
builtins.bool *
-names
->Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
-typing.Hashable"typing.Hashable
-'builtins.list[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX	
-reset_index'pandas.core.frame.DataFrame.reset_index"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-level
-NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level-
-typing.Sequence[Unknown]"typing.Sequence **
-drop
-
builtins.bool"
builtins.bool *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *q
-	col_level`
- Union[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str *2
-col_fill"
-typing.Hashable"typing.Hashable *6
-allow_duplicates
-
builtins.bool"
builtins.bool *
-names
->Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
-typing.Hashable"typing.Hashable
-'builtins.list[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX2`
-dropna"pandas.core.frame.DataFrame.dropna
-dropna"pandas.core.frame.DataFrame.dropna"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-how
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *R
-threshD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-subset
-Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
-TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
-uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX 
-dropna"pandas.core.frame.DataFrame.dropna":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-how
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *R
-threshD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-subset
-Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
-TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
-uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadX 
-dropna"pandas.core.frame.DataFrame.dropna"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-how
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *R
-threshD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-subset
-Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
-TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
-uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-None *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None 0:typing.overloadX2:
-sort_values'pandas.core.frame.DataFrame.sort_values
-sort_values'pandas.core.frame.DataFrame.sort_values"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-1Union[builtins.str,typing.Sequence[builtins.str]]
-builtins.str"builtins.strN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -7972,56 +5980,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX
-sort_values'pandas.core.frame.DataFrame.sort_values":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-1Union[builtins.str,typing.Sequence[builtins.str]]
-builtins.str"builtins.strN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8029,62 +5996,17 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX
-sort_values'pandas.core.frame.DataFrame.sort_values"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-1Union[builtins.str,typing.Sequence[builtins.str]]
-builtins.str"builtins.strN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8092,58 +6014,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2A
-
-sort_index&pandas.core.frame.DataFrame.sort_index
-
-sort_index&pandas.core.frame.DataFrame.sort_index"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8151,65 +6030,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX
-
-sort_index&pandas.core.frame.DataFrame.sort_index":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8217,71 +6046,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX
-
-sort_index&pandas.core.frame.DataFrame.sort_index"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8289,1179 +6062,266 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2
-groupby#pandas.core.frame.DataFrame.groupby)
-groupby#pandas.core.frame.DataFrame.groupby"
-pandas.core.groupby.generic.DataFrameGroupBy[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"
-Vpandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*b
-byZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"
-Vpandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*f
-by^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"
-Opandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.period.Period]F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*X
-byP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"
-Fpandas.core.groupby.generic.DataFrameGroupBy[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX&
-groupby#pandas.core.frame.DataFrame.groupby"
-Apandas.core.groupby.generic.DataFrameGroupBy[builtins.tuple[Any]].
-builtins.tuple[Any]
-Any"builtins.tuple",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-Union[pandas.core.indexes.multi.MultiIndex,TypeAlias[Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]]],None]L
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex
-TypeAlias[Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]]]
-Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]].
-builtins.tuple[Any]
-Any"builtins.tuple
-)builtins.list[pandas._typing._HashableTa]S
-pandas._typing._HashableTa"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
-=TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]]
-2Union[numpy.ufunc,CallableType[builtins.function]]
-numpy.ufunc"numpy.ufuncK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Function)
-builtins.list[Unknown]"
builtins.list
--builtins.list[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"
builtins.list9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayq
-%builtins.list[numpy.ndarray[Any,Any]]9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.list
-:typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any]
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label
-Any"typing.Mappingu
-*builtins.list[typing.Mapping[Unknown,Any]]8
-typing.Mapping[Unknown,Any]
-Any"typing.Mapping"
builtins.list
-2builtins.list[pandas.core.indexes.base.Index[Any]]N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"
builtins.listJ
-#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper
-2builtins.list[pandas.core.groupby.grouper.Grouper]J
-#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"
builtins.list"%pandas._typing.GroupByObjectNonScalar
-None *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX!
-groupby#pandas.core.frame.DataFrame.groupby"
-Fpandas.core.groupby.generic.DataFrameGroupBy[pandas._typing.SeriesByT]
-
-pandas._typing.SeriesByT	
-Union[builtins.str,builtins.bytes,datetime.date,builtins.bool,builtins.int,builtins.float,builtins.complex,datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-
-by
-
-3pandas.core.series.Series[pandas._typing.SeriesByT]
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
 
-pandas._typing.SeriesByT	
-Union[builtins.str,builtins.bytes,datetime.date,builtins.bool,builtins.int,builtins.float,builtins.complex,datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+numpy.void"
+numpy.void"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg
+None *
 
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"j
-1pandas.core.groupby.generic.DataFrameGroupBy[Any]
-Any",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-|Union[pandas.core.indexes.category.CategoricalIndex[Any],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any]]l
-2pandas.core.indexes.category.CategoricalIndex[Any]
-Any"-pandas.core.indexes.category.CategoricalIndexN
+columns
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.IndexD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None 0:typing.overload:builtins.classmethodXp
+	from_dict%pandas.core.frame.DataFrame.from_dict":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*p
+clsg
+!Type[pandas.core.frame.DataFrame]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"type*C
+data9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict*
+orient
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+dtype
+4Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],None]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX2
-aggpandas.core.frame.DataFrame.agg
-
-aggpandas.core.frame.DataFrame.agg"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-kwargs
-Any0:typing.overloadX
-aggpandas.core.frame.DataFrame.agg":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-func
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-kwargs
-Any0:typing.overloadX2
-	aggregate%pandas.core.frame.DataFrame.aggregate
-	aggregate%pandas.core.frame.DataFrame.aggregate"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-kwargs
-Any0:typing.overloadX
-	aggregate%pandas.core.frame.DataFrame.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-func
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-kwargs
-Any0:typing.overloadX2
-apply!pandas.core.frame.DataFrame.apply
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-kwargs
-Any0:typing.overloadX!
-apply!pandas.core.frame.DataFrame.apply"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *
-result_type
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-
-apply!pandas.core.frame.DataFrame.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn*H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX2
-count!pandas.core.frame.DataFrame.count
-
-count!pandas.core.frame.DataFrame.count":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
-numeric_only
-
builtins.bool"
builtins.bool *
-level
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level0:typing.overloadX
-count!pandas.core.frame.DataFrame.count"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool 0:typing.overloadX2
-mode pandas.core.frame.DataFrame.mode
-
-mode pandas.core.frame.DataFrame.mode":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *,
-skipna
-
builtins.bool"
builtins.bool *2
-numeric_only
-
builtins.bool"
builtins.bool *
-level
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level*
-kwargs
-Any0:typing.overloadX	
-mode pandas.core.frame.DataFrame.mode"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX2!
-quantile$pandas.core.frame.DataFrame.quantile
-quantile$pandas.core.frame.DataFrame.quantile"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*)
-q 
-builtins.float"builtins.float *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
-numeric_only
-
builtins.bool"
builtins.bool *
-
interpolation
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -9469,337 +6329,106 @@ tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod 0:typing.overloadX
-quantile$pandas.core.frame.DataFrame.quantile":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-q
-;Union[builtins.list[builtins.float],numpy.ndarray[Any,Any]]P
-builtins.list[builtins.float] 
-builtins.float"builtins.float"
builtins.list9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
-numeric_only
-
builtins.bool"
builtins.bool *
-
interpolation
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod 0:typing.overloadX2
-
-columns#pandas.core.frame.DataFrame.columns
-columns#pandas.core.frame.DataFrame.columns"l
-,pandas.core.indexes.base.Index[builtins.str]
-builtins.str"builtins.str"pandas.core.indexes.base.Index*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame0:builtins.propertyX`
-columns#pandas.core.frame.DataFrame.columns"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-cols
-Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[pandas._typing.HashableT],builtins.tuple[pandas._typing.HashableT]]
-kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
-`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.AnyArrayLike
-'builtins.list[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
-(builtins.tuple[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple0:.setter2
-index!pandas.core.frame.DataFrame.index
-index!pandas.core.frame.DataFrame.index"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame0:builtins.propertyX`
-index!pandas.core.frame.DataFrame.index"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*W
-idxN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index0:.setter2
-allpandas.core.frame.DataFrame.all
-allpandas.core.frame.DataFrame.all"
-
builtins.bool"
builtins.bool*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-None*X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX	
-allpandas.core.frame.DataFrame.all"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX2
-anypandas.core.frame.DataFrame.any
-anypandas.core.frame.DataFrame.any"
-
builtins.bool"
builtins.bool*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-None*X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX	
-anypandas.core.frame.DataFrame.any"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX2
-bfill!pandas.core.frame.DataFrame.bfill
-bfill!pandas.core.frame.DataFrame.bfill"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX
-bfill!pandas.core.frame.DataFrame.bfill":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2
-ffill!pandas.core.frame.DataFrame.ffill
-ffill!pandas.core.frame.DataFrame.ffill"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX
-ffill!pandas.core.frame.DataFrame.ffill":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2X
-interpolate'pandas.core.frame.DataFrame.interpolate
-interpolate'pandas.core.frame.DataFrame.interpolate"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-method
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -9809,6 +6438,10 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -9827,6 +6460,16 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -9835,64 +6478,38 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-limit_direction
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-
-limit_area
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *x
-downcasth
-!Union[Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-kwargs
-Any0:typing.overloadX
-interpolate'pandas.core.frame.DataFrame.interpolate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-method
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -9923,61 +6540,23 @@ limit_area
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-limit_direction
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-
-limit_area
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *x
-downcasth
-!Union[Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX
-interpolate'pandas.core.frame.DataFrame.interpolate"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-method
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10013,224 +6592,39 @@ limit_area
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-limit_direction
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-
-limit_area
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *x
-downcasth
-!Union[Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *
-kwargs
-Any0:typing.overloadX2,
-rename_axis'pandas.core.frame.DataFrame.rename_axis
-
-rename_axis'pandas.core.frame.DataFrame.rename_axis"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-mapper
-Any *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX
-
-rename_axis'pandas.core.frame.DataFrame.rename_axis":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-mapper
-Any *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadX
-rename_axis'pandas.core.frame.DataFrame.rename_axis"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-index
-Union[builtins.str,typing.Sequence[builtins.str],builtins.dict[Union[builtins.str,builtins.int],builtins.str],CallableType[builtins.function],None]
-builtins.str"builtins.strN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence
-pandas.core.window.rolling.Window[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"!pandas.core.window.rolling.Window*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-window
-{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
-builtins.int"builtins.int
-builtins.str"builtins.str(
-datetime.timedelta"datetime.timedeltaP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
- pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
-min_periodsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *,
-center
-
builtins.bool"
builtins.bool *W
-onM
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-closed
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10238,62 +6632,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType
-None *P
-stepD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod **
-win_type
-builtins.str"builtins.str0:typing.overloadX
-rolling#pandas.core.frame.DataFrame.rolling"
-?pandas.core.window.rolling.Rolling[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame""pandas.core.window.rolling.Rolling*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-window
-{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
-builtins.int"builtins.int
-builtins.str"builtins.str(
-datetime.timedelta"datetime.timedeltaP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
- pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
-min_periodsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *,
-center
-
builtins.bool"
builtins.bool *W
-onM
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-closed
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10301,51 +6644,13 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType
-None *P
-stepD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod *
-win_type
-None 0:typing.overloadX2[
-to_json#pandas.core.frame.DataFrame.to_json
-to_json#pandas.core.frame.DataFrame.to_json"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-path_or_buf
-hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
-8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
--Union[builtins.str,os.PathLike[builtins.str]]
-builtins.str"builtins.strF
-os.PathLike[builtins.str]
-builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
-(pandas._typing.WriteBuffer[builtins.str]
-builtins.str"builtins.str"pandas._typing.WriteBuffer*C
-orient7
-Literal[builtins.str]	
-builtins.str"builtins.str*
-date_format
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *4
-double_precision
-builtins.int"builtins.int *1
-force_ascii
-
builtins.bool"
builtins.bool *
-	date_unit
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10353,19 +6658,7 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-default_handler
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None *E
-lines:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-compression
-TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
-Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
-None7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10377,42 +6670,15 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-*TypeAlias[builtins.dict[builtins.str,Any]]W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
-index
-
builtins.bool"
builtins.bool *R
-indentD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *A
-mode7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str0:typing.overloadX
-to_json#pandas.core.frame.DataFrame.to_json"
-builtins.str"builtins.str*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-path_or_buf
-None *C
-orient7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-date_format
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *4
-double_precision
-builtins.int"builtins.int *1
-force_ascii
-
builtins.bool"
builtins.bool *
-	date_unit
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10420,19 +6686,7 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-default_handler
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None *E
-lines:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-compression
-TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
-Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
-None7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10444,55 +6698,139 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-*TypeAlias[builtins.dict[builtins.str,Any]]W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
-index
-
builtins.bool"
builtins.bool *R
-indentD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *A
-mode7
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
 Literal[builtins.str]	
-builtins.str"builtins.str0:typing.overloadX
-to_json#pandas.core.frame.DataFrame.to_json"
-builtins.str"builtins.str*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-path_or_buf
-None *
-orient
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg
+None 0:typing.overload:builtins.classmethodXp20
+to_dict#pandas.core.frame.DataFrame.to_dict
+to_dict#pandas.core.frame.DataFrame.to_dict"
+9builtins.list[typing.MutableMapping[typing.Hashable,Any]]p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping"
builtins.list*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
+orient7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"
+1builtins.list[builtins.dict[typing.Hashable,Any]]`
+"builtins.dict[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"
builtins.dict"
builtins.list*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
+orient7
+Literal[builtins.str]	
+builtins.str"builtins.str*m
+intoa
+Type[builtins.dict[Any,Any]]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict"type *G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.JsonFrameOrient
-None *
-date_format
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str*
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *4
-double_precision
-builtins.int"builtins.int *1
-force_ascii
-
builtins.bool"
builtins.bool *
-	date_unit
+builtins.str"builtins.str*
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*+
+index
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
 ^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -10501,22 +6839,50 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-default_handler
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None *+
-lines
-
builtins.bool"
builtins.bool *
-compression
-TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
-Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
-None7
+builtins.str"builtins.str *
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str *
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*+
+index
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"`
+"builtins.dict[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"
builtins.dict*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10524,84 +6890,109 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-*TypeAlias[builtins.dict[builtins.str,Any]]W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
-index
-
builtins.bool"
builtins.bool *R
-indentD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *C
-mode7
+builtins.str"builtins.str *m
+intoa
+Type[builtins.dict[Any,Any]]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict"type *G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"`
+"builtins.dict[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"
builtins.dict*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
-builtins.str"builtins.str 0:typing.overloadX
-to_json#pandas.core.frame.DataFrame.to_json"
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *m
+intoa
+Type[builtins.dict[Any,Any]]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict"type *+
+index
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+
+to_parquet&pandas.core.frame.DataFrame.to_parquet
+
+to_parquet&pandas.core.frame.DataFrame.to_parquet"
 None*D
 self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-path_or_buf
-hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path
+jUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.bytes]]
 8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
 -Union[builtins.str,os.PathLike[builtins.str]]
 builtins.str"builtins.strF
 os.PathLike[builtins.str]
-builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
-(pandas._typing.WriteBuffer[builtins.str]
-builtins.str"builtins.str"pandas._typing.WriteBuffer*
-orient
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathj
+*pandas._typing.WriteBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.WriteBuffer*
+engine
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.ParquetEngine *
+compression
+yUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.JsonFrameOrient
-None *
-date_format
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str
-None *4
-double_precision
-builtins.int"builtins.int *1
-force_ascii
-
builtins.bool"
builtins.bool *
-	date_unit
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *T
+indexG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+partition_cols
+3Union[builtins.list[pandas._typing.HashableT],None]
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions *
+kwargs
+Any0:typing.overloadX
+
+to_parquet&pandas.core.frame.DataFrame.to_parquet" 
+builtins.bytes"builtins.bytes*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path
+None *
+engine
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-default_handler
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None *+
-lines
-
builtins.bool"
builtins.bool *
-compression
-TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
-Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
-None7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.ParquetEngine *
+compression
+yUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10611,82 +7002,132 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.str"builtins.str
+None *T
+indexG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+partition_cols
+3Union[builtins.list[pandas._typing.HashableT],None]
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
-index
-
builtins.bool"
builtins.bool *R
-indentD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *C
-mode7
-Literal[builtins.str]	
-builtins.str"builtins.str 0:typing.overloadX2;
-	to_string%pandas.core.frame.DataFrame.to_string 
-	to_string%pandas.core.frame.DataFrame.to_string"
+Any"
builtins.dict
+None"pandas._typing.StorageOptions *
+kwargs
+Any0:typing.overloadX2
+to_orc"pandas.core.frame.DataFrame.to_orc
+to_orc"pandas.core.frame.DataFrame.to_orc"
 None*D
 self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-buf
-hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path
+jUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.bytes]]
 8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
 -Union[builtins.str,os.PathLike[builtins.str]]
 builtins.str"builtins.strF
 os.PathLike[builtins.str]
-builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
-(pandas._typing.WriteBuffer[builtins.str]
-builtins.str"builtins.str"pandas._typing.WriteBuffer*
-columns
-wUnion[builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None *
-	col_space
-jUnion[builtins.int,builtins.list[builtins.int],builtins.dict[pandas._typing.HashableT2,builtins.int],None]
-builtins.int"builtins.intJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-5builtins.dict[pandas._typing.HashableT2,builtins.int]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable
-builtins.int"builtins.int"
builtins.dict
-None *
-header
-MUnion[builtins.bool,builtins.list[builtins.str],builtins.tuple[builtins.str]]
-
builtins.bool"
builtins.boolJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.listL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tuple *+
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathj
+*pandas._typing.WriteBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.WriteBuffer*E
+engine7
+Literal[builtins.str]	
+builtins.str"builtins.str *T
+indexG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+
engine_kwargs
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None 0:typing.overloadX
+to_orc"pandas.core.frame.DataFrame.to_orc" 
+builtins.bytes"builtins.bytes*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path
+None *E
+engine7
+Literal[builtins.str]	
+builtins.str"builtins.str *T
+indexG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+
engine_kwargs
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None 0:typing.overloadX2I
+to_html#pandas.core.frame.DataFrame.to_html&
+to_html#pandas.core.frame.DataFrame.to_html"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+buf
+hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer*
+columns
+vUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None *
+	col_space
+Union[TypeAlias[Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]],None]
+TypeAlias[Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]]
+Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]
+builtins.str"builtins.str
+builtins.int"builtins.int
+1typing.Sequence[Union[builtins.int,builtins.str]]`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str"typing.Sequence
+@typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]"
+typing.Hashable"typing.Hashable`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.int"typing.Mapping"pandas._typing.ColspaceArgType
+None *,
+header
+
builtins.bool"
builtins.bool *+
 index
 
builtins.bool"
builtins.bool **
 na_rep
-builtins.str"builtins.str *	
+builtins.str"builtins.str *
 
-formatters	
-Union[TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]],None]
-TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]]
-Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]
+formatters
+Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[typing.Hashable,CallableType[builtins.function]],None]
 .builtins.list[CallableType[builtins.function]]K
 CallableType[builtins.function]&
 builtins.function"builtins.function"
builtins.list
 /builtins.tuple[CallableType[builtins.function]]K
 CallableType[builtins.function]&
-builtins.function"builtins.function"builtins.tuple
-Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]`
- Union[builtins.str,builtins.int]
-builtins.str"builtins.str
-builtins.int"builtins.intK
+builtins.function"builtins.function"builtins.tuple
+?typing.Mapping[typing.Hashable,CallableType[builtins.function]]"
+typing.Hashable"typing.HashableK
 CallableType[builtins.function]&
-builtins.function"builtins.function"typing.Mapping"pandas._typing.FormattersType
+builtins.function"builtins.function"typing.Mapping
 None *
 float_format
 +Union[CallableType[builtins.function],None]K
@@ -10698,9 +7139,30 @@ Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]
 
builtins.bool"
builtins.bool
 None *1
 index_names
-
builtins.bool"
builtins.bool *S
-justifyD
-Union[builtins.str,None]
+
builtins.bool"
builtins.bool *
+justify
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
 builtins.str"builtins.str
 None *T
 max_rowsD
@@ -10714,75 +7176,79 @@ Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]
 show_dimensions
 
builtins.bool"
builtins.bool *+
 decimal
-builtins.str"builtins.str *V
-
-line_widthD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *T
-min_rowsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *X
-max_colwidthD
+builtins.str"builtins.str */
+	bold_rows
+
builtins.bool"
builtins.bool *
+classes
+)Union[typing.Sequence[builtins.str],None]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+None *,
+escape
+
builtins.bool"
builtins.bool *.
+notebook
+
builtins.bool"
builtins.bool *R
+borderD
 Union[builtins.int,None]
 builtins.int"builtins.int
 None *T
+table_idD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *2
+render_links
+
builtins.bool"
builtins.bool *T
 encodingD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None 0:typing.overloadX
-	to_string%pandas.core.frame.DataFrame.to_string"
+None 0:typing.overloadX!
+to_html#pandas.core.frame.DataFrame.to_html"
 builtins.str"builtins.str*D
 self:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 buf
-None *
-columns
-vUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
-'builtins.list[pandas._typing.HashableT]Q
+None *
+columns
+5Union[typing.Sequence[pandas._typing.HashableT],None]
+)typing.Sequence[pandas._typing.HashableT]Q
 pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None *
-	col_space
-`Union[builtins.int,builtins.list[builtins.int],builtins.dict[typing.Hashable,builtins.int],None]
-builtins.int"builtins.intJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list~
-+builtins.dict[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"
builtins.dict
-None *
-header
-2Union[builtins.bool,typing.Sequence[builtins.str]]
-
builtins.bool"
builtins.boolN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence *+
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Sequence
+None *
+	col_space
+Union[TypeAlias[Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]],None]
+TypeAlias[Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]]
+Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]
+builtins.str"builtins.str
+builtins.int"builtins.int
+1typing.Sequence[Union[builtins.int,builtins.str]]`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str"typing.Sequence
+@typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]"
+typing.Hashable"typing.Hashable`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.int"typing.Mapping"pandas._typing.ColspaceArgType
+None *,
+header
+
builtins.bool"
builtins.bool *+
 index
 
builtins.bool"
builtins.bool **
 na_rep
-builtins.str"builtins.str *	
+builtins.str"builtins.str *
 
-formatters	
-Union[TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]],None]
-TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]]
-Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]
+formatters
+Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[typing.Hashable,CallableType[builtins.function]],None]
 .builtins.list[CallableType[builtins.function]]K
 CallableType[builtins.function]&
 builtins.function"builtins.function"
builtins.list
 /builtins.tuple[CallableType[builtins.function]]K
 CallableType[builtins.function]&
-builtins.function"builtins.function"builtins.tuple
-Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]`
- Union[builtins.str,builtins.int]
-builtins.str"builtins.str
-builtins.int"builtins.intK
+builtins.function"builtins.function"builtins.tuple
+?typing.Mapping[typing.Hashable,CallableType[builtins.function]]"
+typing.Hashable"typing.HashableK
 CallableType[builtins.function]&
-builtins.function"builtins.function"typing.Mapping"pandas._typing.FormattersType
+builtins.function"builtins.function"typing.Mapping
 None *
 float_format
 +Union[CallableType[builtins.function],None]K
@@ -10794,9 +7260,30 @@ Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]
 
builtins.bool"
builtins.bool
 None *1
 index_names
-
builtins.bool"
builtins.bool *S
-justifyD
-Union[builtins.str,None]
+
builtins.bool"
builtins.bool *
+justify
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
 builtins.str"builtins.str
 None *T
 max_rowsD
@@ -10810,425 +7297,8729 @@ Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]
 show_dimensions
 
builtins.bool"
builtins.bool *+
 decimal
-builtins.str"builtins.str *V
-
-line_widthD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *T
-min_rowsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *X
-max_colwidthD
+builtins.str"builtins.str */
+	bold_rows
+
builtins.bool"
builtins.bool *
+classes
+)Union[typing.Sequence[builtins.str],None]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+None *,
+escape
+
builtins.bool"
builtins.bool *.
+notebook
+
builtins.bool"
builtins.bool *R
+borderD
 Union[builtins.int,None]
 builtins.int"builtins.int
 None *T
+table_idD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *2
+render_links
+
builtins.bool"
builtins.bool *T
 encodingD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None 0:typing.overloadXr:
-__hash__$pandas.core.frame.DataFrame.__hash__
-NonerT
-sparse"pandas.core.frame.DataFrame.sparse&
-builtins.ellipsis"builtins.ellipsisrF
-Name pandas.core.frame.DataFrame.Name
-builtins.str"builtins.str
-Grouper#pandas.core.groupby.grouper.Grouper"builtins.object*U
-__new__+pandas.core.groupby.grouper.Grouper.__new__*
-cls*
-args*
-
-kwargs*
-__init__,pandas.core.groupby.grouper.Grouper.__init__"
-None*T
-selfJ
-#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper*
-key
-Any *
-level
-Any *
-freq
-Any *(
-axis
-builtins.int"builtins.int **
-sort
-
builtins.bool"
builtins.bool *M
-ax&pandas.core.groupby.grouper.Grouper.ax*
-self0:builtins.property`*U
-groups*pandas.core.groupby.grouper.Grouper.groups*
-self0:builtins.property`rV
-key'pandas.core.groupby.grouper.Grouper.key&
-builtins.ellipsis"builtins.ellipsisrZ
-level)pandas.core.groupby.grouper.Grouper.level&
-builtins.ellipsis"builtins.ellipsisrX
-freq(pandas.core.groupby.grouper.Grouper.freq&
-builtins.ellipsis"builtins.ellipsisrX
-axis(pandas.core.groupby.grouper.Grouper.axis&
-builtins.ellipsis"builtins.ellipsisrX
-sort(pandas.core.groupby.grouper.Grouper.sort&
-builtins.ellipsis"builtins.ellipsisr^
-grouper+pandas.core.groupby.grouper.Grouper.grouper&
-builtins.ellipsis"builtins.ellipsisrV
-obj'pandas.core.groupby.grouper.Grouper.obj&
-builtins.ellipsis"builtins.ellipsisr^
-indexer+pandas.core.groupby.grouper.Grouper.indexer&
-builtins.ellipsis"builtins.ellipsisr\
-binner*pandas.core.groupby.grouper.Grouper.binner&
-builtins.ellipsis"builtins.ellipsis.
-NamedAgg$pandas.core.groupby.generic.NamedAgg"builtins.tuple*
+None 0:typing.overloadX2<
+to_xml"pandas.core.frame.DataFrame.to_xml 
+to_xml"pandas.core.frame.DataFrame.to_xml"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buffer
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.bytes],pandas._typing.WriteBuffer[builtins.str]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathj
+*pandas._typing.WriteBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.WriteBufferd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer*+
+index
+
builtins.bool"
builtins.bool *-
+	root_name
+builtins.str"builtins.str *,
+row_name
+builtins.str"builtins.str *R
+na_repD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *
+	attr_cols
+4Union[builtins.list[pandas._typing.HashableT1],None]
+(builtins.list[pandas._typing.HashableT1]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
+	elem_cols
+4Union[builtins.list[pandas._typing.HashableT2],None]
+(builtins.list[pandas._typing.HashableT2]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
 
-_replace-pandas.core.groupby.generic.NamedAgg._replace"
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
-_self
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar**
-column
-builtins.str"builtins.str *
-aggfunc
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar *
+namespaces
+@Union[builtins.dict[Union[builtins.str,None],builtins.str],None]
+4builtins.dict[Union[builtins.str,None],builtins.str]D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None
+builtins.str"builtins.str"
builtins.dict
+None *R
+prefixD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+encoding
+builtins.str"builtins.str *5
+xml_declaration
+
builtins.bool"
builtins.bool *2
+pretty_print
+
builtins.bool"
builtins.bool *
+parser
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.XMLParsers *
 
-__new__,pandas.core.groupby.generic.NamedAgg.__new__"
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
-_cls
-.Type[pandas.core.groupby.generic.NamedAgg._NT]
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar"type**
-column
-builtins.str"builtins.str *
-aggfunc
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar *
-_asdict,pandas.core.groupby.generic.NamedAgg._asdict"W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict*
-_self
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
-_make*pandas.core.groupby.generic.NamedAgg._make"
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
-_cls
-.Type[pandas.core.groupby.generic.NamedAgg._NT]
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar"type*>
-iterable0
-typing.Iterable[Any]
-Any"typing.Iterable*
-new
-Any *
-len
-Any 0:prS
-column+pandas.core.groupby.generic.NamedAgg.column
-builtins.str"builtins.strr
-aggfunc,pandas.core.groupby.generic.NamedAgg.aggfunc
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalarrS
-column+pandas.core.groupby.generic.NamedAgg.column
-builtins.str"builtins.strr
-aggfunc,pandas.core.groupby.generic.NamedAgg.aggfunc
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalarr
-_fields,pandas.core.groupby.generic.NamedAgg._fields`
- Tuple[builtins.str,builtins.str]
-builtins.str"builtins.str
-builtins.str"builtins.strr
-_field_types1pandas.core.groupby.generic.NamedAgg._field_typesW
+stylesheet
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.str],pandas._typing.ReadBuffer[builtins.bytes],None]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathb
+'pandas._typing.ReadBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.ReadBufferh
+)pandas._typing.ReadBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer
+None *
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dictr
-_field_defaults4pandas.core.groupby.generic.NamedAgg._field_defaultsW
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dictrU
-_source,pandas.core.groupby.generic.NamedAgg._source
-builtins.str"builtins.strr
-__annotations__4pandas.core.groupby.generic.NamedAgg.__annotations__W
+Any"
builtins.dict
+None"pandas._typing.StorageOptions 0:typing.overloadX
+to_xml"pandas.core.frame.DataFrame.to_xml"
+builtins.str"builtins.str*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buffer
+None *+
+index
+
builtins.bool"
builtins.bool *U
+	root_nameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *T
+row_nameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *R
+na_repD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *
+	attr_cols
+4Union[builtins.list[pandas._typing.HashableT1],None]
+(builtins.list[pandas._typing.HashableT1]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
+	elem_cols
+4Union[builtins.list[pandas._typing.HashableT2],None]
+(builtins.list[pandas._typing.HashableT2]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
+
+namespaces
+@Union[builtins.dict[Union[builtins.str,None],builtins.str],None]
+4builtins.dict[Union[builtins.str,None],builtins.str]D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None
+builtins.str"builtins.str"
builtins.dict
+None *R
+prefixD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+encoding
+builtins.str"builtins.str *^
+xml_declarationG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *[
+pretty_printG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *R
+parserD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *
+
+stylesheet
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.str],pandas._typing.ReadBuffer[builtins.bytes],None]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathb
+'pandas._typing.ReadBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.ReadBufferh
+)pandas._typing.ReadBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer
+None *
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict
-CategoricalIndex-pandas.core.indexes.category.CategoricalIndex",pandas.core.indexes.extension.ExtensionIndex"#pandas.core.accessor.PandasDelegate*I
-__new__5pandas.core.indexes.category.CategoricalIndex.__new__"
-2pandas.core.indexes.category.CategoricalIndex.Self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex(*
-cls
-8Type[pandas.core.indexes.category.CategoricalIndex.Self]
-2pandas.core.indexes.category.CategoricalIndex.Self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions 0:typing.overloadX2
+__getitem__'pandas.core.frame.DataFrame.__getitem__
+__getitem__'pandas.core.frame.DataFrame.__getitem__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*<:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],builtins.tuple[typing.Hashable]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+
datetime.date"
datetime.date&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex("type*
-data
-"typing.Iterable[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Iterable *
-
-categories
-Any *
-ordered
-Any *
-dtype
-Any **
-copy
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.ScalarU
+builtins.tuple[typing.Hashable]"
+typing.Hashable"typing.Hashable"builtins.tuple0:typing.overloadX
+__getitem__'pandas.core.frame.DataFrame.__getitem__":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*<:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+6Union[typing.Iterable[typing.Hashable],builtins.slice]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable 
+builtins.slice"builtins.slice0:typing.overloadX
+__getitem__'pandas.core.frame.DataFrame.__getitem__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*<:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*$"
+typing.Hashable"typing.Hashable0:typing.overloadX2
+query!pandas.core.frame.DataFrame.query
+query!pandas.core.frame.DataFrame.query"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*&
+expr
+builtins.str"builtins.str*G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+kwargs
+Any0:typing.overloadX
+query!pandas.core.frame.DataFrame.query":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*&
+expr
+builtins.str"builtins.str*I
+inplace:
+Literal[builtins.bool]	
 
builtins.bool"
builtins.bool *
-name
-Any *S
-equals4pandas.core.indexes.category.CategoricalIndex.equals*
-self*	
-other*
-
inferred_type;pandas.core.indexes.category.CategoricalIndex.inferred_type"
-builtins.str"builtins.str*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
+kwargs
+Any0:typing.overloadX2 
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes"
+NoReturn
+*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*	
+include	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
 Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg*
+exclude
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]],None]
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
 Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*_
-values4pandas.core.indexes.category.CategoricalIndex.values*
-self0:builtins.property`*
-__contains__:pandas.core.indexes.category.CategoricalIndex.__contains__"
-
builtins.bool"
builtins.bool*
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
 Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*	
-Any*
-	__array__7pandas.core.indexes.category.CategoricalIndex.__array__"9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList
+None 0:typing.overloadX
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes"
+NoReturn
+*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+include
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]],None]
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList
+None*	
+exclude	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg0:typing.overloadX
+
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes"
+NoReturn
+*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*	
+exclude	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg0:typing.overloadX
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes"
+NoReturn
+*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
+include6
+builtins.list[NoReturn]
+NoReturn
+"
builtins.list*C
+exclude6
+builtins.list[NoReturn]
+NoReturn
+"
builtins.list0:typing.overloadX	
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*ŵ
+include
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList*
+exclude
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]],None]
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList
+None 0:typing.overloadX	
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+include
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]],None]
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList
+None*ŵ
+exclude
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList0:typing.overloadX
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*ŵ
+exclude
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList0:typing.overloadX2^
+rename"pandas.core.frame.DataFrame.rename
+rename"pandas.core.frame.DataFrame.rename"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+index
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+columns
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+rename"pandas.core.frame.DataFrame.rename":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+index
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+columns
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+rename"pandas.core.frame.DataFrame.rename"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+index
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+columns
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *-
+inplace
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2[
+fillna"pandas.core.frame.DataFrame.fillna
+fillna"pandas.core.frame.DataFrame.fillna"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dictD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *)
+limit
+builtins.int"builtins.int *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX
+fillna"pandas.core.frame.DataFrame.fillna":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dictD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *)
+limit
+builtins.int"builtins.int *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+fillna"pandas.core.frame.DataFrame.fillna"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dictD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *)
+limit
+builtins.int"builtins.int *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2J
+replace#pandas.core.frame.DataFrame.replace
+replace#pandas.core.frame.DataFrame.replace"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+
+to_replace
+Any *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,typing.Sequence[Any],typing.Mapping[Any,Any],re.Pattern[Any],None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType0
+typing.Sequence[Any]
+Any"typing.Sequence;
+typing.Mapping[Any,Any]
+Any
+Any"typing.Mapping&
+re.Pattern[Any]
+Any"
+re.Pattern
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX
+replace#pandas.core.frame.DataFrame.replace":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+
+to_replace
+Any *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,typing.Sequence[Any],typing.Mapping[Any,Any],re.Pattern[Any],None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType0
+typing.Sequence[Any]
+Any"typing.Sequence;
+typing.Mapping[Any,Any]
+Any
+Any"typing.Mapping&
+re.Pattern[Any]
+Any"
+re.Pattern
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX
+replace#pandas.core.frame.DataFrame.replace"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+
+to_replace
+Any *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,typing.Sequence[Any],typing.Mapping[Any,Any],re.Pattern[Any],None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType0
+typing.Sequence[Any]
+Any"typing.Sequence;
+typing.Mapping[Any,Any]
+Any
+Any"typing.Mapping&
+re.Pattern[Any]
+Any"
+re.Pattern
+None *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX2
+	set_index%pandas.core.frame.DataFrame.set_index	
+	set_index%pandas.core.frame.DataFrame.set_index"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+keys
+Union[TypeAlias[Union[typing.Hashable,None]],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],typing.Iterator[pandas._typing.HashableT],builtins.list[pandas._typing.HashableT]]
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.LabelD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+)typing.Iterator[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Iterator
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list**
+drop
+
builtins.bool"
builtins.bool *,
+append
+
builtins.bool"
builtins.bool *6
+verify_integrity
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX
+
+	set_index%pandas.core.frame.DataFrame.set_index":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+keys
+Union[TypeAlias[Union[typing.Hashable,None]],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],typing.Iterator[pandas._typing.HashableT],builtins.list[pandas._typing.HashableT]]
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.LabelD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+)typing.Iterator[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Iterator
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list**
+drop
+
builtins.bool"
builtins.bool *,
+append
+
builtins.bool"
builtins.bool *6
+verify_integrity
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+reset_index'pandas.core.frame.DataFrame.reset_index
+reset_index'pandas.core.frame.DataFrame.reset_index"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level-
+typing.Sequence[Unknown]"typing.Sequence **
+drop
+
builtins.bool"
builtins.bool *q
+	col_level`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str *2
+col_fill"
+typing.Hashable"typing.Hashable *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*6
+allow_duplicates
+
builtins.bool"
builtins.bool *
+names
+>Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
+typing.Hashable"typing.Hashable
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX
+reset_index'pandas.core.frame.DataFrame.reset_index":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level-
+typing.Sequence[Unknown]"typing.Sequence *q
+	col_level`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str *2
+col_fill"
+typing.Hashable"typing.Hashable **
+drop
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *6
+allow_duplicates
+
builtins.bool"
builtins.bool *
+names
+>Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
+typing.Hashable"typing.Hashable
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX	
+reset_index'pandas.core.frame.DataFrame.reset_index"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level-
+typing.Sequence[Unknown]"typing.Sequence **
+drop
+
builtins.bool"
builtins.bool *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *q
+	col_level`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str *2
+col_fill"
+typing.Hashable"typing.Hashable *6
+allow_duplicates
+
builtins.bool"
builtins.bool *
+names
+>Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
+typing.Hashable"typing.Hashable
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX2`
+dropna"pandas.core.frame.DataFrame.dropna
+dropna"pandas.core.frame.DataFrame.dropna"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+how
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *R
+threshD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+subset
+Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
+TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
+uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
+typing.Sequence[Any]
+Any"typing.Sequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX 
+dropna"pandas.core.frame.DataFrame.dropna":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+how
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *R
+threshD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+subset
+Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
+TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
+uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
+typing.Sequence[Any]
+Any"typing.Sequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX 
+dropna"pandas.core.frame.DataFrame.dropna"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+how
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *R
+threshD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+subset
+Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
+TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
+uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
+typing.Sequence[Any]
+Any"typing.Sequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+None *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None 0:typing.overloadX2:
+sort_values'pandas.core.frame.DataFrame.sort_values
+sort_values'pandas.core.frame.DataFrame.sort_values"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+1Union[builtins.str,typing.Sequence[builtins.str]]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *2
+ignore_index
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX
+sort_values'pandas.core.frame.DataFrame.sort_values":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+1Union[builtins.str,typing.Sequence[builtins.str]]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *2
+ignore_index
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX
+sort_values'pandas.core.frame.DataFrame.sort_values"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+1Union[builtins.str,typing.Sequence[builtins.str]]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *2
+ignore_index
+
builtins.bool"
builtins.bool *
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX2A
+
+sort_index&pandas.core.frame.DataFrame.sort_index
+
+sort_index&pandas.core.frame.DataFrame.sort_index"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *4
+sort_remaining
+
builtins.bool"
builtins.bool *2
+ignore_index
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX
+
+sort_index&pandas.core.frame.DataFrame.sort_index":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+level
+rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.LevelJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.listJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list
+None *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *4
+sort_remaining
+
builtins.bool"
builtins.bool *2
+ignore_index
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX
+
+sort_index&pandas.core.frame.DataFrame.sort_index"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+level
+rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.LevelJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.listJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list
+None *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *4
+sort_remaining
+
builtins.bool"
builtins.bool *2
+ignore_index
+
builtins.bool"
builtins.bool *
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX2
+
+value_counts(pandas.core.frame.DataFrame.value_counts
+value_counts(pandas.core.frame.DataFrame.value_counts"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+subset
+,Union[typing.Sequence[typing.Hashable],None]W
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence
+None *K
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+value_counts(pandas.core.frame.DataFrame.value_counts"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*I
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+subset
+,Union[typing.Sequence[typing.Hashable],None]W
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence
+None **
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+groupby#pandas.core.frame.DataFrame.groupby*
+groupby#pandas.core.frame.DataFrame.groupby"
+pandas.core.groupby.generic.DataFrameGroupBy[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"
+Vpandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.timestamps.Timestamp]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*b
+byZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"
+Vpandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*f
+by^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"
+Opandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.period.Period]F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*X
+byP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"
+Fpandas.core.groupby.generic.DataFrameGroupBy[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX'
+groupby#pandas.core.frame.DataFrame.groupby"
+Apandas.core.groupby.generic.DataFrameGroupBy[builtins.tuple[Any]].
+builtins.tuple[Any]
+Any"builtins.tuple",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+Union[pandas.core.indexes.multi.MultiIndex,TypeAlias[Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]]],None]L
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex
+TypeAlias[Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]]]
+Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]].
+builtins.tuple[Any]
+Any"builtins.tuple
+)builtins.list[pandas._typing._HashableTa]S
+pandas._typing._HashableTa"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+=TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]]
+2Union[numpy.ufunc,CallableType[builtins.function]]
+numpy.ufunc"numpy.ufuncK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Function)
+builtins.list[Unknown]"
builtins.list
+-builtins.list[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series"
builtins.list9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayq
+%builtins.list[numpy.ndarray[Any,Any]]9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.list
+:typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any]
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label
+Any"typing.Mappingu
+*builtins.list[typing.Mapping[Unknown,Any]]8
+typing.Mapping[Unknown,Any]
+Any"typing.Mapping"
builtins.list
+2builtins.list[pandas.core.indexes.base.Index[Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"
builtins.listJ
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper
+2builtins.list[pandas.core.groupby.grouper.Grouper]J
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"
builtins.list"%pandas._typing.GroupByObjectNonScalar
+None *
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX"
+groupby#pandas.core.frame.DataFrame.groupby"
+Fpandas.core.groupby.generic.DataFrameGroupBy[pandas._typing.SeriesByT]
+
+pandas._typing.SeriesByT	
+Union[builtins.str,builtins.bytes,datetime.date,builtins.bool,builtins.int,builtins.float,builtins.complex,datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
+pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+
+by
+
+3pandas.core.series.Series[pandas._typing.SeriesByT]
+
+pandas._typing.SeriesByT	
+Union[builtins.str,builtins.bytes,datetime.date,builtins.bool,builtins.int,builtins.float,builtins.complex,datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
+pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"pandas.core.series.Series*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"j
+1pandas.core.groupby.generic.DataFrameGroupBy[Any]
+Any",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+|Union[pandas.core.indexes.category.CategoricalIndex[Any],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any]]l
+2pandas.core.indexes.category.CategoricalIndex[Any]
+Any"-pandas.core.indexes.category.CategoricalIndexN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+stack!pandas.core.frame.DataFrame.stack
+stack!pandas.core.frame.DataFrame.stack"
+AUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any]]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level)
+builtins.list[Unknown]"
builtins.list *,
+dropna
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool 0:typing.overloadX
+stack!pandas.core.frame.DataFrame.stack"
+AUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any]]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level)
+builtins.list[Unknown]"
builtins.list *2
+future_stack
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+aggpandas.core.frame.DataFrame.agg
+aggpandas.core.frame.DataFrame.agg"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+func
+Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase
+;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
+0typing.Mapping[pandas._typing.HashableT,Unknown]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+kwargs
+Any0:typing.overloadX
+aggpandas.core.frame.DataFrame.agg":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+func
+Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
+Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
+YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
+Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.HashableV
+%Union[Unknown,builtins.list[Unknown]])
+builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+kwargs
+Any0:typing.overloadX2
+	aggregate%pandas.core.frame.DataFrame.aggregate
+	aggregate%pandas.core.frame.DataFrame.aggregate"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+func
+Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase
+;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
+0typing.Mapping[pandas._typing.HashableT,Unknown]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+kwargs
+Any0:typing.overloadX
+	aggregate%pandas.core.frame.DataFrame.aggregate":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+func
+Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
+Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
+YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
+Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.HashableV
+%Union[Unknown,builtins.list[Unknown]])
+builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+kwargs
+Any0:typing.overloadX2
+apply!pandas.core.frame.DataFrame.apply
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *
+result_type
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+
+apply!pandas.core.frame.DataFrame.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn*H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX2
+count!pandas.core.frame.DataFrame.count
+
+count!pandas.core.frame.DataFrame.count":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
+numeric_only
+
builtins.bool"
builtins.bool *
+level
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level0:typing.overloadX
+count!pandas.core.frame.DataFrame.count"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+mode pandas.core.frame.DataFrame.mode
+
+mode pandas.core.frame.DataFrame.mode":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *,
+skipna
+
builtins.bool"
builtins.bool *2
+numeric_only
+
builtins.bool"
builtins.bool *
+level
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level*
+kwargs
+Any0:typing.overloadX	
+mode pandas.core.frame.DataFrame.mode"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX2!
+quantile$pandas.core.frame.DataFrame.quantile
+quantile$pandas.core.frame.DataFrame.quantile"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*)
+q 
+builtins.float"builtins.float *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
+numeric_only
+
builtins.bool"
builtins.bool *
+
interpolation
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod 0:typing.overloadX
+quantile$pandas.core.frame.DataFrame.quantile":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+q
+;Union[builtins.list[builtins.float],numpy.ndarray[Any,Any]]P
+builtins.list[builtins.float] 
+builtins.float"builtins.float"
builtins.list9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
+numeric_only
+
builtins.bool"
builtins.bool *
+
interpolation
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod 0:typing.overloadX2
+
+columns#pandas.core.frame.DataFrame.columns
+columns#pandas.core.frame.DataFrame.columns"l
+,pandas.core.indexes.base.Index[builtins.str]
+builtins.str"builtins.str"pandas.core.indexes.base.Index*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame0:builtins.propertyX`
+columns#pandas.core.frame.DataFrame.columns"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+cols
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[pandas._typing.HashableT],builtins.tuple[pandas._typing.HashableT]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple0:.setter2
+index!pandas.core.frame.DataFrame.index
+index!pandas.core.frame.DataFrame.index"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame0:builtins.propertyX`
+index!pandas.core.frame.DataFrame.index"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*W
+idxN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index0:.setter2
+allpandas.core.frame.DataFrame.all
+allpandas.core.frame.DataFrame.all"
+
builtins.bool"
builtins.bool*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+None*X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX	
+allpandas.core.frame.DataFrame.all"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX2
+anypandas.core.frame.DataFrame.any
+anypandas.core.frame.DataFrame.any"
+
builtins.bool"
builtins.bool*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+None*X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX	
+anypandas.core.frame.DataFrame.any"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX2
+bfill!pandas.core.frame.DataFrame.bfill
+bfill!pandas.core.frame.DataFrame.bfill"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX
+bfill!pandas.core.frame.DataFrame.bfill":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2
+ffill!pandas.core.frame.DataFrame.ffill
+ffill!pandas.core.frame.DataFrame.ffill"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX
+ffill!pandas.core.frame.DataFrame.ffill":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2
+getpandas.core.frame.DataFrame.get
+getpandas.core.frame.DataFrame.get"~
+*Union[pandas.core.series.Series[Any],None]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*+
+key"
+typing.Hashable"typing.Hashable*
+default
+None 0:typing.overloadX
+getpandas.core.frame.DataFrame.get"
+6Union[pandas.core.series.Series[Any],pandas._typing.T]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*+
+key"
+typing.Hashable"typing.Hashable*V
+defaultI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object0:typing.overloadX
+getpandas.core.frame.DataFrame.get"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*\
+keyS
+builtins.list[typing.Hashable]"
+typing.Hashable"typing.Hashable"
builtins.list*
+default
+None 0:typing.overloadX
+getpandas.core.frame.DataFrame.get"
+3Union[pandas.core.frame.DataFrame,pandas._typing.T]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*\
+keyS
+builtins.list[typing.Hashable]"
+typing.Hashable"typing.Hashable"
builtins.list*V
+defaultI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object0:typing.overloadX2X
+interpolate'pandas.core.frame.DataFrame.interpolate
+interpolate'pandas.core.frame.DataFrame.interpolate"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+method
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+limit_direction
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+
+limit_area
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *x
+downcasth
+!Union[Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+kwargs
+Any0:typing.overloadX
+interpolate'pandas.core.frame.DataFrame.interpolate":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+method
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+limit_direction
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+
+limit_area
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *x
+downcasth
+!Union[Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX
+interpolate'pandas.core.frame.DataFrame.interpolate"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+method
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+limit_direction
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+
+limit_area
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *x
+downcasth
+!Union[Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+kwargs
+Any0:typing.overloadX2,
+rename_axis'pandas.core.frame.DataFrame.rename_axis
+
+rename_axis'pandas.core.frame.DataFrame.rename_axis"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+Any *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX
+
+rename_axis'pandas.core.frame.DataFrame.rename_axis":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+Any *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+rename_axis'pandas.core.frame.DataFrame.rename_axis"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+index
+Union[builtins.str,typing.Sequence[builtins.str],builtins.dict[Union[builtins.str,builtins.int],builtins.str],CallableType[builtins.function],None]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+pandas.core.window.rolling.Window[pandas.core.frame.DataFrame]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"!pandas.core.window.rolling.Window*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+window
+{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
+builtins.int"builtins.int
+builtins.str"builtins.str(
+datetime.timedelta"datetime.timedeltaP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
+ pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
+min_periodsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+center
+
builtins.bool"
builtins.bool *W
+onM
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+closed
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType
+None *P
+stepD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod **
+win_type
+builtins.str"builtins.str0:typing.overloadX
+rolling#pandas.core.frame.DataFrame.rolling"
+?pandas.core.window.rolling.Rolling[pandas.core.frame.DataFrame]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame""pandas.core.window.rolling.Rolling*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+window
+{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
+builtins.int"builtins.int
+builtins.str"builtins.str(
+datetime.timedelta"datetime.timedeltaP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
+ pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
+min_periodsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+center
+
builtins.bool"
builtins.bool *W
+onM
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+closed
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType
+None *P
+stepD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod *
+win_type
+None 0:typing.overloadX2`
+to_json#pandas.core.frame.DataFrame.to_json
+to_json#pandas.core.frame.DataFrame.to_json"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buf
+hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer*C
+orient7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+date_format
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *4
+double_precision
+builtins.int"builtins.int *1
+force_ascii
+
builtins.bool"
builtins.bool *
+	date_unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit *
+default_handler
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *E
+lines:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
+index
+
builtins.bool"
builtins.bool *R
+indentD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *A
+mode7
+Literal[builtins.str]	
+builtins.str"builtins.str0:typing.overloadX
+to_json#pandas.core.frame.DataFrame.to_json"
+builtins.str"builtins.str*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buf
+None *C
+orient7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+date_format
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *4
+double_precision
+builtins.int"builtins.int *1
+force_ascii
+
builtins.bool"
builtins.bool *
+	date_unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit *
+default_handler
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *E
+lines:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
+index
+
builtins.bool"
builtins.bool *R
+indentD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *A
+mode7
+Literal[builtins.str]	
+builtins.str"builtins.str0:typing.overloadX
+to_json#pandas.core.frame.DataFrame.to_json"
+builtins.str"builtins.str*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buf
+None *
+orient
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.JsonFrameOrient
+None *
+date_format
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *4
+double_precision
+builtins.int"builtins.int *1
+force_ascii
+
builtins.bool"
builtins.bool *
+	date_unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit *
+default_handler
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *+
+lines
+
builtins.bool"
builtins.bool *
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
+index
+
builtins.bool"
builtins.bool *R
+indentD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *C
+mode7
+Literal[builtins.str]	
+builtins.str"builtins.str 0:typing.overloadX
+to_json#pandas.core.frame.DataFrame.to_json"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buf
+hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer*
+orient
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.JsonFrameOrient
+None *
+date_format
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *4
+double_precision
+builtins.int"builtins.int *1
+force_ascii
+
builtins.bool"
builtins.bool *
+	date_unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit *
+default_handler
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *+
+lines
+
builtins.bool"
builtins.bool *
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
+index
+
builtins.bool"
builtins.bool *R
+indentD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *C
+mode7
+Literal[builtins.str]	
+builtins.str"builtins.str 0:typing.overloadX2;
+	to_string%pandas.core.frame.DataFrame.to_string 
+	to_string%pandas.core.frame.DataFrame.to_string"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+buf
+hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer*
+columns
+wUnion[builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
+(builtins.list[pandas._typing.HashableT1]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None *
+	col_space
+jUnion[builtins.int,builtins.list[builtins.int],builtins.dict[pandas._typing.HashableT2,builtins.int],None]
+builtins.int"builtins.intJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+5builtins.dict[pandas._typing.HashableT2,builtins.int]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable
+builtins.int"builtins.int"
builtins.dict
+None *
+header
+MUnion[builtins.bool,builtins.list[builtins.str],builtins.tuple[builtins.str]]
+
builtins.bool"
builtins.boolJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.listL
+builtins.tuple[builtins.str]
+builtins.str"builtins.str"builtins.tuple *+
+index
+
builtins.bool"
builtins.bool **
+na_rep
+builtins.str"builtins.str *	
+
+formatters	
+Union[TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]],None]
+TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]]
+Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]
+.builtins.list[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"
builtins.list
+/builtins.tuple[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"builtins.tuple
+Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.intK
+CallableType[builtins.function]&
+builtins.function"builtins.function"typing.Mapping"pandas._typing.FormattersType
+None *
+float_format
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *W
+sparsifyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *1
+index_names
+
builtins.bool"
builtins.bool *S
+justifyD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *T
+max_rowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+max_colsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *5
+show_dimensions
+
builtins.bool"
builtins.bool *+
+decimal
+builtins.str"builtins.str *V
+
+line_widthD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+min_rowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *X
+max_colwidthD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+encodingD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None 0:typing.overloadX
+	to_string%pandas.core.frame.DataFrame.to_string"
+builtins.str"builtins.str*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+buf
+None *
+columns
+vUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None *
+	col_space
+`Union[builtins.int,builtins.list[builtins.int],builtins.dict[typing.Hashable,builtins.int],None]
+builtins.int"builtins.intJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list~
++builtins.dict[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"
builtins.dict
+None *
+header
+2Union[builtins.bool,typing.Sequence[builtins.str]]
+
builtins.bool"
builtins.boolN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence *+
+index
+
builtins.bool"
builtins.bool **
+na_rep
+builtins.str"builtins.str *	
+
+formatters	
+Union[TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]],None]
+TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]]
+Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]
+.builtins.list[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"
builtins.list
+/builtins.tuple[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"builtins.tuple
+Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.intK
+CallableType[builtins.function]&
+builtins.function"builtins.function"typing.Mapping"pandas._typing.FormattersType
+None *
+float_format
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *W
+sparsifyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *1
+index_names
+
builtins.bool"
builtins.bool *S
+justifyD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *T
+max_rowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+max_colsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *5
+show_dimensions
+
builtins.bool"
builtins.bool *+
+decimal
+builtins.str"builtins.str *V
+
+line_widthD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+min_rowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *X
+max_colwidthD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+encodingD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None 0:typing.overloadXr:
+__hash__$pandas.core.frame.DataFrame.__hash__
+NonerT
+sparse"pandas.core.frame.DataFrame.sparse&
+builtins.ellipsis"builtins.ellipsisrF
+Name pandas.core.frame.DataFrame.Name
+builtins.str"builtins.str5
+Grouper#pandas.core.groupby.grouper.Grouper"builtins.object*
+__repr__,pandas.core.groupby.grouper.Grouper.__repr__"
+builtins.str"builtins.str*LJ
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper0:typing.finalP2
+__new__+pandas.core.groupby.grouper.Grouper.__new__
+__new__+pandas.core.groupby.grouper.Grouper.__new__"
+(pandas.core.groupby.grouper.Grouper.SelfJ
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper(*
+cls
+.Type[pandas.core.groupby.grouper.Grouper.Self]
+(pandas.core.groupby.grouper.Grouper.SelfJ
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper("type*l
+keya
+Union[TypeAlias[Any],None]7
+TypeAlias[Any]
+Any"pandas._typing.KeysArgType
+None *
+level
+Union[TypeAlias[Union[typing.Hashable,builtins.int]],TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]]
+Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]
+0typing.MutableSequence[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.MutableSequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
+builtins.range"builtins.range"pandas._typing.ListLikeHashable
+None *	
+axis	
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault **
+sort
+
builtins.bool"
builtins.bool *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+__new__+pandas.core.groupby.grouper.Grouper.__new__"D
+ pandas.core.resample.TimeGrouper" pandas.core.resample.TimeGrouper*
+cls
+)Type[pandas.core.groupby.grouper.Grouper]J
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"type*
+args
+Any*
+freq
+ETypeAlias[Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]]
+:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.strP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas._typing.Frequency*
+kwargs
+Any0:typing.overloadXr
+key'pandas.core.groupby.grouper.Grouper.keya
+Union[TypeAlias[Any],None]7
+TypeAlias[Any]
+Any"pandas._typing.KeysArgType
+Noner	
+level)pandas.core.groupby.grouper.Grouper.level
+Union[TypeAlias[Union[typing.Hashable,builtins.int]],TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]]
+Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]
+0typing.MutableSequence[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.MutableSequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
+builtins.range"builtins.range"pandas._typing.ListLikeHashable
+Noner
+freq(pandas.core.groupby.grouper.Grouper.freq
+QUnion[TypeAlias[Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]],None]
+ETypeAlias[Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]]
+:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.strP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas._typing.Frequency
+Noner
+axis(pandas.core.groupby.grouper.Grouper.axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.AxisrP
+sort(pandas.core.groupby.grouper.Grouper.sort
+
builtins.bool"
builtins.boolrT
+dropna*pandas.core.groupby.grouper.Grouper.dropna
+
builtins.bool"
builtins.boolrl
+binner*pandas.core.groupby.grouper.Grouper.binner6
+TypeAlias[Any]
+Any"pandas._typing.Incomplete.
+NamedAgg$pandas.core.groupby.generic.NamedAgg"builtins.tuple*
+
+_replace-pandas.core.groupby.generic.NamedAgg._replace"
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_self
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar**
+column
+builtins.str"builtins.str *
+aggfunc
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar *
+
+__new__,pandas.core.groupby.generic.NamedAgg.__new__"
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_cls
+.Type[pandas.core.groupby.generic.NamedAgg._NT]
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar"type*(
+column
+builtins.str"builtins.str*
+aggfunc
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_asdict,pandas.core.groupby.generic.NamedAgg._asdict"W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*
+_self
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_make*pandas.core.groupby.generic.NamedAgg._make"
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_cls
+.Type[pandas.core.groupby.generic.NamedAgg._NT]
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar"type*>
+iterable0
+typing.Iterable[Any]
+Any"typing.Iterable*
+new
+Any *
+len
+Any 0:prS
+column+pandas.core.groupby.generic.NamedAgg.column
+builtins.str"builtins.strr
+aggfunc,pandas.core.groupby.generic.NamedAgg.aggfunc
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalarrS
+column+pandas.core.groupby.generic.NamedAgg.column
+builtins.str"builtins.strr
+aggfunc,pandas.core.groupby.generic.NamedAgg.aggfunc
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalarr
+_fields,pandas.core.groupby.generic.NamedAgg._fields`
+ Tuple[builtins.str,builtins.str]
+builtins.str"builtins.str
+builtins.str"builtins.strr
+_field_types1pandas.core.groupby.generic.NamedAgg._field_typesW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dictr
+_field_defaults4pandas.core.groupby.generic.NamedAgg._field_defaultsW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dictrU
+_source,pandas.core.groupby.generic.NamedAgg._source
+builtins.str"builtins.strr
+__annotations__4pandas.core.groupby.generic.NamedAgg.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+CategoricalIndex-pandas.core.indexes.category.CategoricalIndex",pandas.core.indexes.extension.ExtensionIndex"#pandas.core.accessor.PandasDelegate*>
+__new__5pandas.core.indexes.category.CategoricalIndex.__new__"
+2pandas.core.indexes.category.CategoricalIndex.Self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
 
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
@@ -11253,23 +16044,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
-dtype
-Any *&
-astype4pandas.core.indexes.category.CategoricalIndex.astype"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex(*
+cls
+8Type[pandas.core.indexes.category.CategoricalIndex.Self]
+2pandas.core.indexes.category.CategoricalIndex.Self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11296,17 +16081,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex("type*
+data
+"typing.Iterable[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
-dtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
-Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
 TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
 Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
 &pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
@@ -11322,21 +16113,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Type[builtins.bool]
 
builtins.bool"
builtins.bool"typeC
 Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype8
-typing.Mapping[Any,Unknown]
-Any"typing.Mapping"pandas._typing.DtypeArg**
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterable *
+
+categories
+Any *
+ordered
+Any *
+dtype
+Any **
 copy
-
builtins.bool"
builtins.bool *e
-fillna4pandas.core.indexes.category.CategoricalIndex.fillna*
-self*
-value *
-downcast *
-	is_unique7pandas.core.indexes.category.CategoricalIndex.is_unique"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool *
+name
+Any *S
+equals4pandas.core.indexes.category.CategoricalIndex.equals*
+self*	
+other*
+
inferred_type;pandas.core.indexes.category.CategoricalIndex.inferred_type"
+builtins.str"builtins.str*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11363,20 +16167,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
-is_monotonic_increasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_increasing"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*_
+values4pandas.core.indexes.category.CategoricalIndex.values*
+self0:builtins.property`*
+__contains__:pandas.core.indexes.category.CategoricalIndex.__contains__"
+
builtins.bool"
builtins.bool*
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11403,20 +16205,60 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*	
+Any*
+	__array__7pandas.core.indexes.category.CategoricalIndex.__array__"9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
-is_monotonic_decreasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_decreasing"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
+dtype
+Any *#
+astype4pandas.core.indexes.category.CategoricalIndex.astype"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11443,24 +16285,159 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
+dtype
+TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
+Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype8
+typing.Mapping[Any,Unknown]
+Any"typing.Mapping"pandas._typing.DtypeArg**
+copy
+
builtins.bool"
builtins.bool *e
+fillna4pandas.core.indexes.category.CategoricalIndex.fillna*
+self*
+value *
+downcast *
+	is_unique7pandas.core.indexes.category.CategoricalIndex.is_unique"
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*U
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
+is_monotonic_increasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_increasing"
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
+is_monotonic_decreasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_decreasing"
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*U
 unique4pandas.core.indexes.category.CategoricalIndex.unique*
 self*
-level *
+level *
 
 duplicated8pandas.core.indexes.category.CategoricalIndex.duplicated"
-Any*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11487,14 +16464,11 @@ duplicated8pandas.core.indexes.category.CategoricalIndex.duplicated"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 keep
 IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
@@ -11502,14 +16476,7 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
 builtins.str"builtins.str:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *S
-get_loc5pandas.core.indexes.category.CategoricalIndex.get_loc*
-self*
-key*l
-	get_value7pandas.core.indexes.category.CategoricalIndex.get_value*
-self*
-seriesArrayLike*
-key*]
+
builtins.bool"
builtins.bool *]
 where3pandas.core.indexes.category.CategoricalIndex.where*
 self*
 cond*
@@ -11532,16 +16499,7 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 get_indexer_non_uniqueDpandas.core.indexes.category.CategoricalIndex.get_indexer_non_unique*
 self*
 
-target*`
-take_nd5pandas.core.indexes.category.CategoricalIndex.take_nd*
-self*
-args*
-
-kwargs*N
-map1pandas.core.indexes.category.CategoricalIndex.map*
-self*
-
-mapper*Q
+target*Q
 delete4pandas.core.indexes.category.CategoricalIndex.delete*
 self*
 loc*[
@@ -11556,8 +16514,8 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 
 categories8pandas.core.indexes.category.CategoricalIndex.categoriesN
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexA
-
DatetimeIndex+pandas.core.indexes.datetimes.DatetimeIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"5pandas.core.indexes.accessors.DatetimeIndexProperties*
+Any"pandas.core.indexes.base.Index>
+
DatetimeIndex+pandas.core.indexes.datetimes.DatetimeIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"5pandas.core.indexes.accessors.DatetimeIndexProperties*
 __init__4pandas.core.indexes.datetimes.DatetimeIndex.__init__"
 None*d
 selfZ
@@ -11586,10 +16544,6 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 freq
 Any *
 tz
-Any */
-	normalize
-
builtins.bool"
builtins.bool *
-closed
 Any *-
 	ambiguous
 builtins.str"builtins.str *.
@@ -11613,13 +16567,11 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 Any *N
 
 __reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
-self*
+self*
 	to_series5pandas.core.indexes.datetimes.DatetimeIndex.to_series"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*d
 selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-keep_tz
-Any *
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
 index
 Any *
 name
@@ -11629,16 +16581,7 @@ __reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
 selfZ
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*(
 freq
-builtins.str"builtins.str *a
-	get_value5pandas.core.indexes.datetimes.DatetimeIndex.get_value*
-self*
-
-series*
-key*b
-get_loc3pandas.core.indexes.datetimes.DatetimeIndex.get_loc*
-self*
-key*
-	tolerance *x
+builtins.str"builtins.str *x
 
slice_indexer9pandas.core.indexes.datetimes.DatetimeIndex.slice_indexer*
 self*
 start *	
@@ -11654,13 +16597,7 @@ __reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
 side
 builtins.str"builtins.str *
 sorter
-Any *
-is_type_compatible>pandas.core.indexes.datetimes.DatetimeIndex.is_type_compatible"
-
builtins.bool"
builtins.bool*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-typ
-Any*
+Any *
 
inferred_type9pandas.core.indexes.datetimes.DatetimeIndex.inferred_type"
 builtins.str"builtins.str*d
 selfZ
@@ -11689,13 +16626,7 @@ start_time
 
include_start
 
builtins.bool"
builtins.bool *1
 include_end
-
builtins.bool"
builtins.bool *
-to_perioddelta:pandas.core.indexes.datetimes.DatetimeIndex.to_perioddelta"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-freq
-Any*
+
builtins.bool"
builtins.bool *
 to_julian_date:pandas.core.indexes.datetimes.DatetimeIndex.to_julian_date"r
 .pandas.core.indexes.base.Index[builtins.float] 
 builtins.float"builtins.float"pandas.core.indexes.base.Index*d
@@ -11717,42 +16648,47 @@ AUnion[numpy.dtype[Any],pandas.core.dtypes.dtypes.DatetimeTZDtype](
 Any"numpy.dtypeV
 )pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype*d
 selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`2
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`2
 __add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__
 __add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
 __add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-]Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex]T
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+Union[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.offsets.BaseOffset](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX2
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX2
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-]Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex]T
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+Union[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.offsets.BaseOffset](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-[Union[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]T
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+mUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadXف
-Indexpandas.core.indexes.base.Index"pandas.core.base.IndexOpsMixin*1
-str"pandas.core.indexes.base.Index.str"
-kpandas.core.strings.StringMethods[pandas.core.indexes.base.Index.Self,pandas.core.indexes.multi.MultiIndex]
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
+Indexpandas.core.indexes.base.Index"pandas.core.base.IndexOpsMixin*/
+str"pandas.core.indexes.base.Index.str"
+pandas.core.strings.StringMethods[pandas.core.indexes.base.Index.Self,pandas.core.indexes.multi.MultiIndex,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11779,66 +16715,24 @@ kpandas.core.strings.StringMethods[pandas.core.indexes.base.Index.Self,pandas.co
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(L
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"!pandas.core.strings.StringMethods*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(0:builtins.property`*
-asi8#pandas.core.indexes.base.Index.asi8"
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(L
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_int64*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool"!pandas.core.strings.StringMethods*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11865,20 +16759,17 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(0:builtins.property`*
 is_"pandas.core.indexes.base.Index.is_"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11905,21 +16796,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
-Any*
+Any*
 __len__&pandas.core.indexes.base.Index.__len__"
-builtins.int"builtins.int*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11946,22 +16834,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 	__array__(pandas.core.indexes.base.Index.__array__"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11988,31 +16873,28 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 dtype
 Any *d
 __array_wrap__-pandas.core.indexes.base.Index.__array_wrap__*
 self*
 
 result*
-context *
+context *
 dtype$pandas.core.indexes.base.Index.dtype"
 STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
 HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 numpy.dtype[numpy.generic]
 
numpy.generic"
numpy.generic"numpy.dtypeP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12039,20 +16921,17 @@ HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 ravel$pandas.core.indexes.base.Index.ravel"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12079,26 +16958,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*)
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*)
 order
 builtins.str"builtins.str *@
 view#pandas.core.indexes.base.Index.view*
 self*	
-cls *&
+cls *"
 astype%pandas.core.indexes.base.Index.astype"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12125,14 +17001,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 dtype
 TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
 Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
@@ -12155,13 +17028,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 typing.Mapping[Any,Unknown]
 Any"typing.Mapping"pandas._typing.DtypeArg**
 copy
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 take#pandas.core.indexes.base.Index.take"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12188,14 +17061,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 indices
 Any*(
 axis
@@ -12212,12 +17082,12 @@ fill_value
 self*
 repeats*
 
-axis *0
-copy#pandas.core.indexes.base.Index.copy"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+axis *(
+copy#pandas.core.indexes.base.Index.copy"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12244,19 +17114,16 @@ fill_value
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12283,14 +17150,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 name
 Any **
 deep
@@ -12302,14 +17166,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 __deepcopy__+pandas.core.indexes.base.Index.__deepcopy__*
 self*
 
-memo *
+memo *
 format%pandas.core.indexes.base.Index.format"J
 builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"
builtins.list*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12336,14 +17200,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index**
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index**
 name
 
builtins.bool"
builtins.bool *
 	formatter
@@ -12352,21 +17213,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.function"builtins.function
 None **
 na_rep
-builtins.str"builtins.str *e
-to_native_types.pandas.core.indexes.base.Index.to_native_types*
-self*
-slicer *
-
-kwargs*G
+builtins.str"builtins.str *G
 
to_flat_index,pandas.core.indexes.base.Index.to_flat_index*
-self*
+self*
 	to_series(pandas.core.indexes.base.Index.to_series"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12393,24 +17249,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 index
 Any *
 name
-Any *
+Any *
 to_frame'pandas.core.indexes.base.Index.to_frame":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12437,24 +17290,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*+
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*+
 index
 
builtins.bool"
builtins.bool *
 name
-Any *
+Any *
 	set_names(pandas.core.indexes.base.Index.set_names"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12481,70 +17331,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 names
 Any*
 level
 Any *-
 inplace
-
builtins.bool"
builtins.bool *
-rename%pandas.core.indexes.base.Index.rename"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-name
-Any*-
-inplace
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 nlevels&pandas.core.indexes.base.Index.nlevels"
-builtins.int"builtins.int*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12571,20 +17374,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 	sortlevel(pandas.core.indexes.base.Index.sortlevel"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12611,27 +17411,24 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 level
 Any */
 	ascending
 
builtins.bool"
builtins.bool *
 sort_remaining
-Any *
+Any *
 get_level_values/pandas.core.indexes.base.Index.get_level_values"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12658,24 +17455,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*k
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*k
 level`
  Union[builtins.int,builtins.str]
 builtins.int"builtins.int
-builtins.str"builtins.str*
+builtins.str"builtins.str*
 	droplevel(pandas.core.indexes.base.Index.droplevel"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12702,27 +17496,24 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 level
 LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
 builtins.int"builtins.int"pandas._typing.Level)
-builtins.list[Unknown]"
builtins.list *
+builtins.list[Unknown]"
builtins.list *
 is_monotonic_increasing6pandas.core.indexes.base.Index.is_monotonic_increasing"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12749,20 +17540,17 @@ LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 is_monotonic_decreasing6pandas.core.indexes.base.Index.is_monotonic_decreasing"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12789,20 +17577,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 	is_unique(pandas.core.indexes.base.Index.is_unique"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12829,20 +17614,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 has_duplicates-pandas.core.indexes.base.Index.has_duplicates"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12869,21 +17651,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 
 is_boolean)pandas.core.indexes.base.Index.is_boolean"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12910,21 +17689,18 @@ is_boolean)pandas.core.indexes.base.Index.is_boolean"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 
 is_integer)pandas.core.indexes.base.Index.is_integer"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12951,20 +17727,17 @@ is_integer)pandas.core.indexes.base.Index.is_integer"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 is_floating*pandas.core.indexes.base.Index.is_floating"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12991,21 +17764,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 
 is_numeric)pandas.core.indexes.base.Index.is_numeric"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13032,20 +17802,17 @@ is_numeric)pandas.core.indexes.base.Index.is_numeric"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 	is_object(pandas.core.indexes.base.Index.is_object"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13072,20 +17839,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 is_categorical-pandas.core.indexes.base.Index.is_categorical"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13112,20 +17876,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 is_interval*pandas.core.indexes.base.Index.is_interval"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13152,20 +17913,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-is_mixed'pandas.core.indexes.base.Index.is_mixed"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*G
+
holds_integer,pandas.core.indexes.base.Index.holds_integer*
+self*
+
inferred_type,pandas.core.indexes.base.Index.inferred_type"
+builtins.str"builtins.str*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13192,27 +17952,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*G
-
holds_integer,pandas.core.indexes.base.Index.holds_integer*
-self*^
-
inferred_type,pandas.core.indexes.base.Index.inferred_type*
-self0:builtins.property`*A
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*A
 
 __reduce__)pandas.core.indexes.base.Index.__reduce__*
-self*
+self*
 hasnans&pandas.core.indexes.base.Index.hasnans"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13239,14 +17992,11 @@ __reduce__)pandas.core.indexes.base.Index.__reduce__*
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*5
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*5
 isna#pandas.core.indexes.base.Index.isna*
 self*7
 notna$pandas.core.indexes.base.Index.notna*
@@ -13254,12 +18004,12 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fillna%pandas.core.indexes.base.Index.fillna*
 self*
 value *
-downcast *0
-dropna%pandas.core.indexes.base.Index.dropna"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+downcast *)
+dropna%pandas.core.indexes.base.Index.dropna"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13286,19 +18036,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13325,25 +18072,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 how
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str */
-unique%pandas.core.indexes.base.Index.unique"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str *(
+unique%pandas.core.indexes.base.Index.unique"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13370,19 +18114,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13409,21 +18150,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 level
-Any *3
-drop_duplicates.pandas.core.indexes.base.Index.drop_duplicates"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any *+
+drop_duplicates.pandas.core.indexes.base.Index.drop_duplicates"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13450,19 +18188,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13489,14 +18224,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 keep
 [Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.bool]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
@@ -13506,7 +18238,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str"pandas._typing.NaPosition:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 
 duplicated)pandas.core.indexes.base.Index.duplicated"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -13515,59 +18247,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-keep
-IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-__and__&pandas.core.indexes.base.Index.__and__"
-NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13594,22 +18278,64 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+keep
+IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+__and__&pandas.core.indexes.base.Index.__and__"
+NoReturn
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __rand__'pandas.core.indexes.base.Index.__rand__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13636,22 +18362,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __or__%pandas.core.indexes.base.Index.__or__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13678,22 +18401,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __ror__&pandas.core.indexes.base.Index.__ror__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13720,22 +18440,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __xor__&pandas.core.indexes.base.Index.__xor__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13762,22 +18479,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __rxor__'pandas.core.indexes.base.Index.__rxor__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13804,21 +18518,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*/
-__neg__&pandas.core.indexes.base.Index.__neg__"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*(
+__neg__&pandas.core.indexes.base.Index.__neg__"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13845,18 +18556,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13883,20 +18591,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 __nonzero__*pandas.core.indexes.base.Index.__nonzero__"
-None*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13923,21 +18628,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 union$pandas.core.indexes.base.Index.union"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13964,14 +18666,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
 RUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any]]
 'builtins.list[pandas._typing.HashableT]Q
@@ -13980,12 +18679,12 @@ RUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[An
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.Index*
 sort
-Any *^
-intersection+pandas.core.indexes.base.Index.intersection"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any *P
+intersection+pandas.core.indexes.base.Index.intersection"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14012,19 +18711,16 @@ RUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[An
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14051,19 +18747,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*.
-other.
-KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*'
+other'
+KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14090,18 +18783,15 @@ KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14128,22 +18818,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(**
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(**
 sort
-
builtins.bool"
builtins.bool *1
+
builtins.bool"
builtins.bool **
 
-difference)pandas.core.indexes.base.Index.difference"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+difference)pandas.core.indexes.base.Index.difference"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14170,19 +18857,16 @@ difference)pandas.core.indexes.base.Index.difference"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14209,14 +18893,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 other
 =Union[builtins.list[Any],pandas.core.indexes.base.Index[Any]],
 builtins.list[Any]
@@ -14226,12 +18907,12 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 sortG
 Union[builtins.bool,None]
 
builtins.bool"
builtins.bool
-None *_
-symmetric_difference3pandas.core.indexes.base.Index.symmetric_difference"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *P
+symmetric_difference3pandas.core.indexes.base.Index.symmetric_difference"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14258,19 +18939,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14297,19 +18975,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*.
-other.
-KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*'
+other'
+KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14336,18 +19011,15 @@ KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14374,24 +19046,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 result_name
 Any *
 sort
-Any *
-get_loc&pandas.core.indexes.base.Index.get_loc"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any * 
+get_loc&pandas.core.indexes.base.Index.get_loc"
+Union[builtins.int,builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+builtins.int"builtins.int 
+builtins.slice"builtins.slice
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14418,14 +19096,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 key
 &TypeAlias[Union[typing.Hashable,None]]M
 Union[typing.Hashable,None]"
@@ -14462,13 +19137,13 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 method *
 level *
 limit *
-	tolerance *
+	tolerance *
 join#pandas.core.indexes.base.Index.join"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14495,14 +19170,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
 Any*'
 how
@@ -14512,15 +19184,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 return_indexers
 
builtins.bool"
builtins.bool **
 sort
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 values%pandas.core.indexes.base.Index.values"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14547,20 +19219,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 array$pandas.core.indexes.base.Index.array"P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14587,20 +19256,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 memory_usage+pandas.core.indexes.base.Index.memory_usage"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14627,67 +19293,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index**
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index**
 deep
 
builtins.bool"
builtins.bool *N
 where$pandas.core.indexes.base.Index.where*
 self*
 cond*
-other *
-is_type_compatible1pandas.core.indexes.base.Index.is_type_compatible"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-kind
-Any*
+other *
 __contains__+pandas.core.indexes.base.Index.__contains__"
-
builtins.bool"
builtins.bool*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14714,20 +19335,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*	
-Any*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*	
+Any*
 __setitem__*pandas.core.indexes.base.Index.__setitem__"
-None*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14754,14 +19372,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*	
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*	
 Any*	
 Any*D
 append%pandas.core.indexes.base.Index.append*
@@ -14770,13 +19385,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 putmask&pandas.core.indexes.base.Index.putmask*
 self*
 mask*	
-value*
+value*
 equals%pandas.core.indexes.base.Index.equals"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14803,22 +19418,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
-Any*
+Any*
 	identical(pandas.core.indexes.base.Index.identical"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14845,14 +19457,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
 Any*@
 asof#pandas.core.indexes.base.Index.asof*
@@ -14861,13 +19470,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 	asof_locs(pandas.core.indexes.base.Index.asof_locs*
 self*	
 where*
-mask*
+mask*
 sort_values*pandas.core.indexes.base.Index.sort_values"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14894,24 +19503,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*4
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*4
 return_indexer
 
builtins.bool"
builtins.bool */
 	ascending
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 sort#pandas.core.indexes.base.Index.sort"
-None*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14938,24 +19544,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 args
 Any*
 kwargs
-Any*
+Any*
 shift$pandas.core.indexes.base.Index.shift"
-None*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14982,14 +19585,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*+
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*+
 periods
 builtins.int"builtins.int *
 freq
@@ -14998,58 +19598,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 self*
 args*
 
-kwargs*T
-	get_value(pandas.core.indexes.base.Index.get_value*
-self*
-
-series*
-key*
-	set_value(pandas.core.indexes.base.Index.set_value"
-None*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-arr
-Any*
-key
-Any*
-value
-Any*e
+kwargs*e
 get_indexer_non_unique5pandas.core.indexes.base.Index.get_indexer_non_unique*
 self*
 
@@ -15059,17 +19608,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 
 target*
 
-kwargs*
+kwargs*
 groupby&pandas.core.indexes.base.Index.groupby"
 5builtins.dict[typing.Hashable,numpy.ndarray[Any,Any]]"
 typing.Hashable"typing.Hashable9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15096,23 +19645,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 values
-Any*
+Any0:typing.finalP*
 map"pandas.core.indexes.base.Index.map"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15139,18 +19685,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 mapper
 Any*
 	na_action
-Any *
+Any *
 isin#pandas.core.indexes.base.Index.isin"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -15158,11 +19701,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15189,14 +19732,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 values
 Any*
 level
@@ -15224,12 +19764,12 @@ slice_locs)pandas.core.indexes.base.Index.slice_locs*
 insert%pandas.core.indexes.base.Index.insert*
 self*
 loc*
-item*0
-drop#pandas.core.indexes.base.Index.drop"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+item*(
+drop#pandas.core.indexes.base.Index.drop"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15256,19 +19796,16 @@ slice_locs)pandas.core.indexes.base.Index.slice_locs*
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15295,25 +19832,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 labels
 Any**
 errors
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 shape$pandas.core.indexes.base.Index.shape"L
 builtins.tuple[builtins.int]
-builtins.int"builtins.int"builtins.tuple*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"builtins.tuple*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15340,14 +19874,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 __eq__%pandas.core.indexes.base.Index.__eq__"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -15355,10 +19886,10 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15385,19 +19916,16 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*$"
-builtins.object"builtins.object*.
-__iter__'pandas.core.indexes.base.Index.__iter__"
-"typing.Iterator[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*$"
+builtins.object"builtins.object*&
+__iter__'pandas.core.indexes.base.Index.__iter__"
+"typing.Iterator[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15424,17 +19952,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Iterator*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterator*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15461,14 +19986,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 __ne__%pandas.core.indexes.base.Index.__ne__"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -15476,10 +19998,10 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15506,15 +20028,12 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*$"
-builtins.object"builtins.object*J
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*$"
+builtins.object"builtins.object*?
 __le__%pandas.core.indexes.base.Index.__le__"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -15522,11 +20041,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15553,19 +20072,161 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*''
+
+rename%pandas.core.indexes.base.Index.rename)
+rename%pandas.core.indexes.base.Index.rename"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -17939,18 +22574,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -17977,35 +22610,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*		
-Union[builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],typing.Sequence[builtins.int],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[builtins.bool],typing.Sequence[builtins.bool],TypeAlias[Unknown]] 
-builtins.slice"builtins.slice
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Indexe
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.SeriesQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence8
-TypeAlias[Unknown]"pandas._typing.np_ndarray_bool0:typing.overloadX4
-__getitem__*pandas.core.indexes.base.Index.__getitem__"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+name
+Any*I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+rename%pandas.core.indexes.base.Index.rename"
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -18032,17 +22652,22 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+name
+Any*G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX2_
+__getitem__*pandas.core.indexes.base.Index.__getitem__2
+__getitem__*pandas.core.indexes.base.Index.__getitem__"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -18069,38 +22694,67 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-Union[builtins.int,builtins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]]
-builtins.int"builtins.int
-nbuiltins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*		
+Union[builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],typing.Sequence[builtins.int],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[builtins.bool],typing.Sequence[builtins.bool],TypeAlias[Unknown]] 
+builtins.slice"builtins.slice
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyint"builtins.tuple0:typing.overloadX24
-__mul__&pandas.core.indexes.base.Index.__mul__
-__mul__&pandas.core.indexes.base.Index.__mul__"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Index[builtins.float]]l
-,pandas.core.indexes.base.Index[builtins.int]
-builtins.int"builtins.int"pandas.core.indexes.base.Indexr
-.pandas.core.indexes.base.Index[builtins.float] 
-builtins.float"builtins.float"pandas.core.indexes.base.Index**(
-datetime.timedelta"datetime.timedelta0:typing.overloadX/
-__mul__&pandas.core.indexes.base.Index.__mul__"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Indexe
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.SeriesQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence8
+TypeAlias[Unknown]"pandas._typing.np_ndarray_bool0:typing.overloadX-
+__getitem__*pandas.core.indexes.base.Index.__getitem__"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -18127,18 +22781,14 @@ bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Ind
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -18165,30 +22815,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*	
-Any0:typing.overloadX23
-__truediv__*pandas.core.indexes.base.Index.__truediv__
-__truediv__*pandas.core.indexes.base.Index.__truediv__"
-NoReturn
-*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+Union[builtins.int,builtins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]]
+builtins.int"builtins.int
+nbuiltins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyint"builtins.tuple0:typing.overloadX2-
+__mul__&pandas.core.indexes.base.Index.__mul__
+__mul__&pandas.core.indexes.base.Index.__mul__"^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
 bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Index[builtins.float]]l
 ,pandas.core.indexes.base.Index[builtins.int]
 builtins.int"builtins.int"pandas.core.indexes.base.Indexr
 .pandas.core.indexes.base.Index[builtins.float] 
 builtins.float"builtins.float"pandas.core.indexes.base.Index**(
-datetime.timedelta"datetime.timedelta0:typing.overloadX/
-__truediv__*pandas.core.indexes.base.Index.__truediv__"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+datetime.timedelta"datetime.timedelta0:typing.overloadX(
+__mul__&pandas.core.indexes.base.Index.__mul__"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -18210,23 +22865,20 @@ bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Ind
 Type[builtins.complex]$
 builtins.complex"builtins.complex"type=
 Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -18253,14 +22905,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*	
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*	
 Any0:typing.overloadXPr=
 __hash__'pandas.core.indexes.base.Index.__hash__
 NonerW
@@ -18269,24 +22918,656 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 notnull&pandas.core.indexes.base.Index.notnull&
 builtins.ellipsis"builtins.ellipsisr[
 __bool__'pandas.core.indexes.base.Index.__bool__&
-builtins.ellipsis"builtins.ellipsis
+builtins.ellipsis"builtins.ellipsis
 
IntervalIndex*pandas.core.indexes.interval.IntervalIndex",pandas.core.indexes.extension.ExtensionIndex"#pandas._libs.interval.IntervalMixin*
 __new__2pandas.core.indexes.interval.IntervalIndex.__new__"
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
+data
+)typing.Sequence[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"typing.Sequence*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None **
+copy
+
builtins.bool"
builtins.bool *.
+name"
+typing.Hashable"typing.Hashable *6
+verify_integrity
+
builtins.bool"
builtins.bool *
+	to_tuples4pandas.core.indexes.interval.IntervalIndex.to_tuples"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*.
+na_tuple
+
builtins.bool"
builtins.bool *
+astype1pandas.core.indexes.interval.IntervalIndex.astype"f
+/pandas.core.indexes.interval.IntervalIndex[Any]
+Any"*pandas.core.indexes.interval.IntervalIndex*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+dtype
+TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
+Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype8
+typing.Mapping[Any,Unknown]
+Any"typing.Mapping"pandas._typing.DtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+
inferred_type8pandas.core.indexes.interval.IntervalIndex.inferred_type"
+builtins.str"builtins.str*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
+memory_usage7pandas.core.indexes.interval.IntervalIndex.memory_usage"
+builtins.int"builtins.int*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex**
+deep
+
builtins.bool"
builtins.bool *
+is_overlapping9pandas.core.indexes.interval.IntervalIndex.is_overlapping"
+
builtins.bool"
builtins.bool*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
+get_loc2pandas.core.indexes.interval.IntervalIndex.get_loc"
+vUnion[builtins.int,builtins.slice,TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+builtins.int"builtins.int 
+builtins.slice"builtins.slice
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+key
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label*
+method
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FillnaOptions7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+	tolerance
+Any *
+get_indexer6pandas.core.indexes.interval.IntervalIndex.get_indexer"
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*Z
+targetN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+method
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FillnaOptions7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+	tolerance
+Any *
+get_indexer_non_uniqueApandas.core.indexes.interval.IntervalIndex.get_indexer_non_unique"*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*Z
+targetN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+left/pandas.core.indexes.interval.IntervalIndex.left"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
+right0pandas.core.indexes.interval.IntervalIndex.right"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
+mid.pandas.core.indexes.interval.IntervalIndex.mid"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
+length1pandas.core.indexes.interval.IntervalIndex.length"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`2Z
+from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks
+from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
+Xpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.int]]l
+,pandas._libs.interval.Interval[builtins.int]
+builtins.int"builtins.int"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
+breaks	
+TypeAlias[Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]]
+Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]N
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Seriesl
+,pandas.core.indexes.base.Index[builtins.int]
+builtins.int"builtins.int"pandas.core.indexes.base.Index"&pandas.core.indexes.interval._EdgesInt*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp
+from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
+Zpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.float]]r
+.pandas._libs.interval.Interval[builtins.float] 
+builtins.float"builtins.float"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
+breaks	
+TypeAlias[Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]]
+Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]T
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayh
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Seriesr
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index"(pandas.core.indexes.interval._EdgesFloat*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp
+from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
+tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]]
+Hpandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
+breaks
+TypeAlias[Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]]
+
+Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]
+ntyping.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]]
+]TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]
+RUnion[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]&
+datetime.datetime"datetime.datetime$
+numpy.datetime64"numpy.datetime64T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._typing.DatetimeLike"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeriesZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex",pandas.core.indexes.interval._EdgesTimestamp*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp
+from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
+tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]]
+Hpandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
+breaks	
+TypeAlias[Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]]
+Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]
+9typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex",pandas.core.indexes.interval._EdgesTimedelta*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp2
+from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays
+from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays"
+Xpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.int]]l
+,pandas._libs.interval.Interval[builtins.int]
+builtins.int"builtins.int"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
+left	
+TypeAlias[Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]]
+Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]N
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Seriesl
+,pandas.core.indexes.base.Index[builtins.int]
+builtins.int"builtins.int"pandas.core.indexes.base.Index"&pandas.core.indexes.interval._EdgesInt*	
+right	
+TypeAlias[Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]]
+Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]N
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Seriesl
+,pandas.core.indexes.base.Index[builtins.int]
+builtins.int"builtins.int"pandas.core.indexes.base.Index"&pandas.core.indexes.interval._EdgesInt*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp
+from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays"
+Zpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.float]]r
+.pandas._libs.interval.Interval[builtins.float] 
+builtins.float"builtins.float"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
+left	
+TypeAlias[Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]]
+Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]T
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayh
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Seriesr
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index"(pandas.core.indexes.interval._EdgesFloat*	
+right	
+TypeAlias[Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]]
+Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]T
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayh
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Seriesr
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index"(pandas.core.indexes.interval._EdgesFloat*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp'
+from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays"
+tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]]
+Hpandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
+left
+TypeAlias[Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]]
+
+Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]
+ntyping.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]]
+]TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]
+RUnion[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]&
+datetime.datetime"datetime.datetime$
+numpy.datetime64"numpy.datetime64T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._typing.DatetimeLike"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeriesZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex",pandas.core.indexes.interval._EdgesTimestamp*
+right
+TypeAlias[Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]]
+
+Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]
+ntyping.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]]
+]TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]
+RUnion[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]&
+datetime.datetime"datetime.datetime$
+numpy.datetime64"numpy.datetime64T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._typing.DatetimeLike"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeriesZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex",pandas.core.indexes.interval._EdgesTimestamp*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp 
+from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays"
+tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]]
+Hpandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
 cls
 JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
-data
-)typing.Sequence[pandas._typing.IntervalT]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
+left	
+TypeAlias[Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]]
+Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]
+9typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex",pandas.core.indexes.interval._EdgesTimedelta*	
+right	
+TypeAlias[Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]]
+Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]
+9typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"typing.Sequence
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex",pandas.core.indexes.interval._EdgesTimedelta*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp2B
+from_tuples6pandas.core.indexes.interval.IntervalIndex.from_tuples
+from_tuples6pandas.core.indexes.interval.IntervalIndex.from_tuples"
+Xpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.int]]l
+,pandas._libs.interval.Interval[builtins.int]
+builtins.int"builtins.int"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"typing.Sequence*
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
+data
+1typing.Sequence[Tuple[builtins.int,builtins.int]]`
+ Tuple[builtins.int,builtins.int]
+builtins.int"builtins.int
+builtins.int"builtins.int"typing.Sequence*
 closed
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
 ^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
@@ -18297,376 +23578,399 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
 dtype
 3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
 'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None **
-copy
-
builtins.bool"
builtins.bool *.
+None 0:typing.overload:builtins.classmethodXp
+from_tuples6pandas.core.indexes.interval.IntervalIndex.from_tuples"
+Zpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.float]]r
+.pandas._libs.interval.Interval[builtins.float] 
+builtins.float"builtins.float"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
+data
+5typing.Sequence[Tuple[builtins.float,builtins.float]]l
+$Tuple[builtins.float,builtins.float] 
+builtins.float"builtins.float 
+builtins.float"builtins.float"typing.Sequence*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
 name"
-typing.Hashable"typing.Hashable *6
-verify_integrity
-
builtins.bool"
builtins.bool *
-	to_tuples4pandas.core.indexes.interval.IntervalIndex.to_tuples"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp
+from_tuples6pandas.core.indexes.interval.IntervalIndex.from_tuples"
+tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]]
+Hpandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*.
-na_tuple
-
builtins.bool"
builtins.bool *
-astype1pandas.core.indexes.interval.IntervalIndex.astype"f
-/pandas.core.indexes.interval.IntervalIndex[Any]
-Any"*pandas.core.indexes.interval.IntervalIndex*
-self
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
+data
+typing.Sequence[Union[Tuple[pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timestamps.Timestamp],Tuple[datetime.datetime,datetime.datetime],Tuple[numpy.datetime64,numpy.datetime64]]]
+Union[Tuple[pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timestamps.Timestamp],Tuple[datetime.datetime,datetime.datetime],Tuple[numpy.datetime64,numpy.datetime64]]
+XTuple[pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timestamps.Timestamp]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp~
+*Tuple[datetime.datetime,datetime.datetime]&
+datetime.datetime"datetime.datetime&
+datetime.datetime"datetime.datetimex
+(Tuple[numpy.datetime64,numpy.datetime64]$
+numpy.datetime64"numpy.datetime64$
+numpy.datetime64"numpy.datetime64"typing.Sequence*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp
+from_tuples6pandas.core.indexes.interval.IntervalIndex.from_tuples"
+tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]]
+Hpandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+cls
+JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-dtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
-Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype8
-typing.Mapping[Any,Unknown]
-Any"typing.Mapping"pandas._typing.DtypeArg**
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
+data
+typing.Sequence[Union[Tuple[pandas._libs.tslibs.timedeltas.Timedelta,pandas._libs.tslibs.timedeltas.Timedelta],Tuple[datetime.timedelta,datetime.timedelta],Tuple[numpy.timedelta64,numpy.timedelta64]]]
+Union[Tuple[pandas._libs.tslibs.timedeltas.Timedelta,pandas._libs.tslibs.timedeltas.Timedelta],Tuple[datetime.timedelta,datetime.timedelta],Tuple[numpy.timedelta64,numpy.timedelta64]]
+XTuple[pandas._libs.tslibs.timedeltas.Timedelta,pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
+,Tuple[datetime.timedelta,datetime.timedelta](
+datetime.timedelta"datetime.timedelta(
+datetime.timedelta"datetime.timedelta~
+*Tuple[numpy.timedelta64,numpy.timedelta64]&
+numpy.timedelta64"numpy.timedelta64&
+numpy.timedelta64"numpy.timedelta64"typing.Sequence*
+closed
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
+name"
+typing.Hashable"typing.Hashable **
 copy
-
builtins.bool"
builtins.bool *
-
inferred_type8pandas.core.indexes.interval.IntervalIndex.inferred_type"
-builtins.str"builtins.str*
-self
+
builtins.bool"
builtins.bool *
+dtype
+3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
+None 0:typing.overload:builtins.classmethodXp2
+__contains__7pandas.core.indexes.interval.IntervalIndex.__contains__
+__contains__7pandas.core.indexes.interval.IntervalIndex.__contains__"
+
builtins.bool"
builtins.bool*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-memory_usage7pandas.core.indexes.interval.IntervalIndex.memory_usage"
-builtins.int"builtins.int*
-self
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval0:typing.overloadX
+__contains__7pandas.core.indexes.interval.IntervalIndex.__contains__":
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex**
-deep
-
builtins.bool"
builtins.bool *
-is_overlapping9pandas.core.indexes.interval.IntervalIndex.is_overlapping"
-
builtins.bool"
builtins.bool*
-self
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*$"
+builtins.object"builtins.object0:typing.overloadX2
+__getitem__6pandas.core.indexes.interval.IntervalIndex.__getitem__
+__getitem__6pandas.core.indexes.interval.IntervalIndex.__getitem__"
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-get_loc2pandas.core.indexes.interval.IntervalIndex.get_loc"
-vUnion[builtins.int,builtins.slice,TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-builtins.int"builtins.int 
-builtins.slice"builtins.slice
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+Union[builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],typing.Sequence[builtins.int],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[builtins.bool],TypeAlias[Unknown]] 
+builtins.slice"builtins.slice
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*
-self
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Indexe
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series8
+TypeAlias[Unknown]"pandas._typing.np_ndarray_bool0:typing.overloadX
+__getitem__6pandas.core.indexes.interval.IntervalIndex.__getitem__"
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-key
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label*
-method
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None *
-	tolerance
-Any *
-get_indexer6pandas.core.indexes.interval.IntervalIndex.get_indexer"
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+builtins.int"builtins.int0:typing.overloadX2
+__gt__1pandas.core.indexes.interval.IntervalIndex.__gt__
+
+__gt__1pandas.core.indexes.interval.IntervalIndex.__gt__"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*
-self
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*Z
-targetN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-method
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-	tolerance
-Any *
-get_indexer_non_uniqueApandas.core.indexes.interval.IntervalIndex.get_indexer_non_unique"*
-self
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+dUnion[pandas._typing.IntervalT,pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*Z
-targetN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-left/pandas.core.indexes.interval.IntervalIndex.left"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:typing.overloadX
+__gt__1pandas.core.indexes.interval.IntervalIndex.__gt__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-right0pandas.core.indexes.interval.IntervalIndex.right"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+3pandas.core.series.Series[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"pandas.core.series.Series0:typing.overloadX2
+__ge__1pandas.core.indexes.interval.IntervalIndex.__ge__
+
+__ge__1pandas.core.indexes.interval.IntervalIndex.__ge__"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-mid.pandas.core.indexes.interval.IntervalIndex.mid"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+dUnion[pandas._typing.IntervalT,pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:typing.overloadX
+__ge__1pandas.core.indexes.interval.IntervalIndex.__ge__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+3pandas.core.series.Series[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"pandas.core.series.Series0:typing.overloadX2
+__le__1pandas.core.indexes.interval.IntervalIndex.__le__
+
+__le__1pandas.core.indexes.interval.IntervalIndex.__le__"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+dUnion[pandas._typing.IntervalT,pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:typing.overloadX
+__le__1pandas.core.indexes.interval.IntervalIndex.__le__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+3pandas.core.series.Series[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"pandas.core.series.Series0:typing.overloadX2
+__lt__1pandas.core.indexes.interval.IntervalIndex.__lt__
+
+__lt__1pandas.core.indexes.interval.IntervalIndex.__lt__"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-length1pandas.core.indexes.interval.IntervalIndex.length"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+dUnion[pandas._typing.IntervalT,pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-	get_value4pandas.core.indexes.interval.IntervalIndex.get_value"
-Any*
-self
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-series
-/TypeAlias[Type[pandas.core.series.Series[Any]]]t
-$Type[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"type"$pandas.core.dtypes.generic.ABCSeries*
-key
-Any*
-is_all_dates7pandas.core.indexes.interval.IntervalIndex.is_all_dates"
-
builtins.bool"
builtins.bool*
-self
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:typing.overloadX
+__lt__1pandas.core.indexes.interval.IntervalIndex.__lt__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`2Z
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
-Xpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.int]]l
-,pandas._libs.interval.Interval[builtins.int]
-builtins.int"builtins.int"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+3pandas.core.series.Series[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-breaks	
-TypeAlias[Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]]
-Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]N
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"pandas.core.series.Series0:typing.overloadX2
+__eq__1pandas.core.indexes.interval.IntervalIndex.__eq__
+
+__eq__1pandas.core.indexes.interval.IntervalIndex.__eq__"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Seriesl
-,pandas.core.indexes.base.Index[builtins.int]
-builtins.int"builtins.int"pandas.core.indexes.base.Index"&pandas.core.indexes.interval._EdgesInt*
-closed
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
-Zpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.float]]r
-.pandas._libs.interval.Interval[builtins.float] 
-builtins.float"builtins.float"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-breaks	
-TypeAlias[Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]]
-Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]T
-typing.Sequence[builtins.float] 
-builtins.float"builtins.float"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayh
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Seriesr
-.pandas.core.indexes.base.Index[builtins.float] 
-builtins.float"builtins.float"pandas.core.indexes.base.Index"(pandas.core.indexes.interval._EdgesFloat*
-closed
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
-tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]]
-Hpandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+dUnion[pandas._typing.IntervalT,pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
-breaks
-TypeAlias[Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:typing.overloadX
+__eq__1pandas.core.indexes.interval.IntervalIndex.__eq__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+3pandas.core.series.Series[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"pandas.core.series.Series0:typing.overloadX
+__eq__1pandas.core.indexes.interval.IntervalIndex.__eq__":
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*$"
+builtins.object"builtins.object0:typing.overloadX2
+__ne__1pandas.core.indexes.interval.IntervalIndex.__ne__
 
-Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]
-ntyping.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]]
-]TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]
-RUnion[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]&
-datetime.datetime"datetime.datetime$
-numpy.datetime64"numpy.datetime64T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._typing.DatetimeLike"typing.Sequence
+__ne__1pandas.core.indexes.interval.IntervalIndex.__ne__"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeriesZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex",pandas.core.indexes.interval._EdgesTimestamp*
-closed
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
-tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]]
-Hpandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-breaks	
-TypeAlias[Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]]
-Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]
-9typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex",pandas.core.indexes.interval._EdgesTimedelta*
-closed
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+dUnion[pandas._typing.IntervalT,pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:typing.overloadX
+__ne__1pandas.core.indexes.interval.IntervalIndex.__ne__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+3pandas.core.series.Series[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"pandas.core.series.Series0:typing.overloadX
+__ne__1pandas.core.indexes.interval.IntervalIndex.__ne__":
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*$"
+builtins.object"builtins.object0:typing.overloadXPr
+closed1pandas.core.indexes.interval.IntervalIndex.closed
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
 ^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
@@ -18676,346 +23980,1145 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp2
-from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays
-from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays"
-Xpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.int]]l
-,pandas._libs.interval.Interval[builtins.int]
-builtins.int"builtins.int"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-left	
-TypeAlias[Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]]
-Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]N
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Seriesl
-,pandas.core.indexes.base.Index[builtins.int]
-builtins.int"builtins.int"pandas.core.indexes.base.Index"&pandas.core.indexes.interval._EdgesInt*	
-right	
-TypeAlias[Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]]
-Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]N
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Seriesl
-,pandas.core.indexes.base.Index[builtins.int]
-builtins.int"builtins.int"pandas.core.indexes.base.Index"&pandas.core.indexes.interval._EdgesInt*
-closed
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType
+
+MultiIndex$pandas.core.indexes.multi.MultiIndex"pandas.core.indexes.base.Index*
+__new__,pandas.core.indexes.multi.MultiIndex.__new__"
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(*
+cls
+/Type[pandas.core.indexes.multi.MultiIndex.Self]
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex("type*
+levels
+Any *
+codes
+Any *
+	sortorder
+Any *
+names
+Any *
+dtype
+Any *
+copy
+Any *
+name
+Any *6
+verify_integrity
+
builtins.bool"
builtins.bool *3
+
_set_identity
+
builtins.bool"
builtins.bool *
+__init__-pandas.core.indexes.multi.MultiIndex.__init__"
+None*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
+levels
+Any *
+codes
+Any *
+	sortorder
+Any *
+names
+Any *
+dtype
+Any *
+copy
+Any *
+name
+Any *6
+verify_integrity
+
builtins.bool"
builtins.bool *3
+
_set_identity
+
builtins.bool"
builtins.bool *
+from_arrays0pandas.core.indexes.multi.MultiIndex.from_arrays"
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(*
+cls
+/Type[pandas.core.indexes.multi.MultiIndex.Self]
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex("type*
+arrays
+Any*
+	sortorder
+Any *
+names
+Any 0:builtins.classmethodp*
+from_tuples0pandas.core.indexes.multi.MultiIndex.from_tuples"
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(*
+cls
+/Type[pandas.core.indexes.multi.MultiIndex.Self]
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex("type*
+tuples
+Any*
+	sortorder
+Any *
+names
+Any 0:builtins.classmethodp*
+from_product1pandas.core.indexes.multi.MultiIndex.from_product"
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(*
+cls
+/Type[pandas.core.indexes.multi.MultiIndex.Self]
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex("type*
+	iterables
+Any*
+	sortorder
+Any *
+names
+Any 0:builtins.classmethodp*
+
+from_frame/pandas.core.indexes.multi.MultiIndex.from_frame"
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(*
+cls
+/Type[pandas.core.indexes.multi.MultiIndex.Self]
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex("type*
+df
+Any*
+	sortorder
+Any *
+names
+Any 0:builtins.classmethodp*T
+shape*pandas.core.indexes.multi.MultiIndex.shape*
+self0:builtins.property`*
+levels+pandas.core.indexes.multi.MultiIndex.levels"
+2builtins.list[pandas.core.indexes.base.Index[Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"
builtins.list*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex0:builtins.property`*
+
+set_levels/pandas.core.indexes.multi.MultiIndex.set_levels"
+Any*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
+levels
+Any*
+level
+Any *6
+verify_integrity
+
builtins.bool"
builtins.bool *T
+codes*pandas.core.indexes.multi.MultiIndex.codes*
+self0:builtins.property`*
+	set_codes.pandas.core.indexes.multi.MultiIndex.set_codes"
+Any*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
+codes
+Any*
+level
+Any *6
+verify_integrity
+
builtins.bool"
builtins.bool *
+copy)pandas.core.indexes.multi.MultiIndex.copy"
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(*
+self
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(*
+names
+Any **
+deep
+
builtins.bool"
builtins.bool *
+	__array__.pandas.core.indexes.multi.MultiIndex.__array__"9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
+dtype
+Any *F
+view)pandas.core.indexes.multi.MultiIndex.view*
+self*	
+cls *
+__contains__1pandas.core.indexes.multi.MultiIndex.__contains__"
+
builtins.bool"
builtins.bool*NL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*	
+Any*
+dtype*pandas.core.indexes.multi.MultiIndex.dtype"(
+numpy.dtype[Any]
+Any"numpy.dtype*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex0:builtins.property`*
+dtypes+pandas.core.indexes.multi.MultiIndex.dtypes"
+pandas.core.series.Series[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]]	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype"pandas.core.series.Series*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex0:builtins.property`*
+memory_usage1pandas.core.indexes.multi.MultiIndex.memory_usage"
+builtins.int"builtins.int*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex**
+deep
+
builtins.bool"
builtins.bool *
+nbytes+pandas.core.indexes.multi.MultiIndex.nbytes"
+builtins.int"builtins.int*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex0:builtins.property`*
+format+pandas.core.indexes.multi.MultiIndex.format",
+builtins.list[Any]
+Any"
builtins.list*V
+selfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*S
+nameG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+	formatter
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *R
+na_repD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *+
+names
+
builtins.bool"
builtins.bool *)
+space
+builtins.int"builtins.int *W
+sparsifyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+adjoin
+
builtins.bool"
builtins.bool *
+__len__,pandas.core.indexes.multi.MultiIndex.__len__"
+builtins.int"builtins.int*NL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*V
+values+pandas.core.indexes.multi.MultiIndex.values*
+self0:builtins.property`*
+is_monotonic_increasing
+interpolate%pandas.core.series.Series.interpolate"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22181,18 +30844,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22219,20 +30879,51 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-repeats
-/Union[builtins.int,builtins.list[builtins.int]]
-builtins.int"builtins.intJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+method
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
+axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
@@ -22240,13 +30931,60 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *
-	to_xarray#pandas.core.series.Series.to_xarray"
-Any*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *-
+inplace
+
builtins.bool"
builtins.bool *
+limit_direction
+MUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+
+limit_area
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *x
+downcasth
+!Union[Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+kwargs
+Any*I
+asofpandas.core.series.Series.asof"#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22273,20 +31011,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*.
-itemspandas.core.series.Series.items"
-9typing.Iterable[Tuple[typing.Hashable,pandas._typing.S1]]
-(Tuple[typing.Hashable,pandas._typing.S1]"
-typing.Hashable"typing.Hashable
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22313,18 +31046,42 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+where
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],typing.Sequence[Unknown]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Iterable*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar-
+typing.Sequence[Unknown]"typing.Sequence*
+subset
+6Union[builtins.str,typing.Sequence[builtins.str],None]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+None *4
+clippandas.core.series.Series.clip"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22351,21 +31108,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-keyspandas.core.series.Series.keys",
-builtins.list[Any]
-Any"
builtins.list*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22392,20 +31143,54 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-to_frame"pandas.core.series.Series.to_frame":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+lower
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.float,None]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike 
+builtins.float"builtins.float
+None *
+upper
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.float,None]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *-
+inplace
+
builtins.bool"
builtins.bool *
+kwargs
+Any*=
+asfreq pandas.core.series.Series.asfreq"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22431,23 +31216,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Type[builtins.object]"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*Y
-nameM
-Union[builtins.object,None]"
-builtins.object"builtins.object
-None *.
-modepandas.core.series.Series.mode"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22474,18 +31252,61 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+freq
+Any*
+method
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FillnaOptions
+None *
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None */
+	normalize
+
builtins.bool"
builtins.bool *
+
+fill_value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+None *+
+at_time!pandas.core.series.Series.at_time"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22512,24 +31333,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dropna
-Any *
-unique pandas.core.series.Series.unique"9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22556,22 +31368,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-duplicated$pandas.core.series.Series.duplicated"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*m
+timec
+!Union[builtins.str,datetime.time]
+builtins.str"builtins.str
+
datetime.time"
datetime.time**
+asof
+
builtins.bool"
builtins.bool *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *+
+between_time&pandas.core.series.Series.between_time"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22598,32 +31418,15 @@ duplicated$pandas.core.series.Series.duplicated"e
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-keep
-[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.bool]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-idxmax pandas.core.series.Series.idxmax"`
- Union[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22650,35 +31453,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*s
+
+start_timec
+!Union[builtins.str,datetime.time]
+builtins.str"builtins.str
+
datetime.time"
datetime.time*q
+end_timec
+!Union[builtins.str,datetime.time]
+builtins.str"builtins.str
+
datetime.time"
datetime.time*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*
-idxmin pandas.core.series.Series.idxmin"`
- Union[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *'
+firstpandas.core.series.Series.first"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22705,31 +31506,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*.
-roundpandas.core.series.Series.round"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22756,18 +31541,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+offset
+Any*'
+lastpandas.core.series.Series.last"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22794,26 +31578,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*,
-decimals
-builtins.int"builtins.int *
-args
-Any*
-kwargs
-Any*0
-corrpandas.core.series.Series.corr" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22840,18 +31613,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+offset
+Any*
+rankpandas.core.series.Series.rank"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22878,15 +31653,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-method
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+method
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *2
+numeric_only
+
builtins.bool"
builtins.bool *
+	na_option
 HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -22894,14 +31687,14 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str */
-min_periods
-builtins.int"builtins.int */
-covpandas.core.series.Series.cov" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+	ascending
+
builtins.bool"
builtins.bool *)
+pct
+
builtins.bool"
builtins.bool *C
+wherepandas.core.series.Series.where"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22928,18 +31721,15 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22966,24 +31756,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*W
-min_periodsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *(
-ddof
-builtins.int"builtins.int *.
-diffpandas.core.series.Series.diff"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+cond
+Union[pandas.core.series.Series[pandas._typing.S1],pandas.core.series.Series[builtins.bool],numpy.ndarray[Any,Any],CallableType[builtins.function],CallableType[builtins.function]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23010,18 +31792,44 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Seriese
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayK
+CallableType[builtins.function]&
+builtins.function"builtins.functionK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+other
+Any *-
+inplace
+
builtins.bool"
builtins.bool *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *i
+maskpandas.core.series.Series.mask"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23048,22 +31856,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int *
-autocorr"pandas.core.series.Series.autocorr" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23090,23 +31891,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-lag
-builtins.int"builtins.int *6
-
-__matmul__$pandas.core.series.Series.__matmul__***8
-__rmatmul__%pandas.core.series.Series.__rmatmul__***U
-combine!pandas.core.series.Series.combine"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+cond
+Union[pandas.core.series.Series[pandas._typing.S1],pandas.core.series.Series[builtins.bool],numpy.ndarray[Any,Any],CallableType[builtins.function],CallableType[builtins.function]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23133,18 +31927,43 @@ __matmul__$pandas.core.series.Series.__matmul__***8
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Seriese
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayK
+CallableType[builtins.function]&
+builtins.function"builtins.functionK
+CallableType[builtins.function]&
+builtins.function"builtins.function*%
+other%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,CallableType[builtins.function],pandas._libs.missing.NAType,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23171,18 +31990,41 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameK
+CallableType[builtins.function]&
+builtins.function"builtins.function:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType
+None *-
+inplace
+
builtins.bool"
builtins.bool *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *6
+	case_when#pandas.core.series.Series.case_when"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23209,20 +32051,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-funcK
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*"
+caselist"
+builtins.list[Tuple[Union[typing.Sequence[builtins.bool],pandas.core.series.Series[builtins.bool],CallableType[builtins.function]],Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],CallableType[builtins.function]]]]
+Tuple[Union[typing.Sequence[builtins.bool],pandas.core.series.Series[builtins.bool],CallableType[builtins.function]],Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],CallableType[builtins.function]]]
+nUnion[typing.Sequence[builtins.bool],pandas.core.series.Series[builtins.bool],CallableType[builtins.function]]Q
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequencee
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.SeriesK
 CallableType[builtins.function]&
-builtins.function"builtins.function*
-
-fill_value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
+builtins.function"builtins.function
+Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],CallableType[builtins.function]]
+TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
+uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
+typing.Sequence[Any]
+Any"typing.Sequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -23240,12 +32095,13 @@ fill_value
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-None *E
-
combine_first'pandas.core.series.Series.combine_first"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.ScalarK
+CallableType[builtins.function]&
+builtins.function"builtins.function"
builtins.list*,
+truncate"pandas.core.series.Series.truncate"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23272,18 +32128,15 @@ fill_value
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23310,18 +32163,39 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+before
+3Union[datetime.date,builtins.str,builtins.int,None]
+
datetime.date"
datetime.date
+builtins.str"builtins.str
+builtins.int"builtins.int
+None *
+after
+3Union[datetime.date,builtins.str,builtins.int,None]
+
datetime.date"
datetime.date
+builtins.str"builtins.str
+builtins.int"builtins.int
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None **
+copy
+
builtins.bool"
builtins.bool *+
+
+tz_convert$pandas.core.series.Series.tz_convert"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23348,20 +32222,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*]
-update pandas.core.series.Series.update"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23388,19 +32257,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*E
-otherE
-Union[pandas.core.series.Series[pandas._typing.S1],typing.Sequence[pandas._typing.S1],typing.Mapping[builtins.int,pandas._typing.S1]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+tz
+Any*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None **
+copy
+
builtins.bool"
builtins.bool *,
+tz_localize%pandas.core.series.Series.tz_localize"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23427,17 +32310,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-"typing.Sequence[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23464,18 +32345,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Sequence
-.typing.Mapping[builtins.int,pandas._typing.S1]
-builtins.int"builtins.int
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+tz
+Any*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None **
+copy
+
builtins.bool"
builtins.bool *
+	ambiguous
+Any */
+nonexistent
+builtins.str"builtins.str *&
+abspandas.core.series.Series.abs"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23502,21 +32402,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Mapping*
-argsort!pandas.core.series.Series.argsort"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23543,38 +32437,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-order
-None *1
-nlargest"pandas.core.series.Series.nlargest"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*c
+describe"pandas.core.series.Series.describe"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23601,18 +32472,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23639,30 +32507,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*%
-n
-builtins.int"builtins.int *
-keep
-ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+percentiles
+)Union[builtins.list[builtins.float],None]P
+builtins.list[builtins.float] 
+builtins.float"builtins.float"
builtins.list
+None *
+include
+BUnion[Literal[builtins.str],builtins.list[pandas._typing.S1],None]7
 Literal[builtins.str]	
-builtins.str"builtins.str *1
-	nsmallest#pandas.core.series.Series.nsmallest"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23689,18 +32550,16 @@ ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[bui
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+None *&
+exclude&
+>Union[pandas._typing.S1,builtins.list[pandas._typing.S1],None]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23727,30 +32586,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*%
-n
-builtins.int"builtins.int *
-keep
-ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition7
-Literal[builtins.str]	
-builtins.str"builtins.str *1
-	swaplevel#pandas.core.series.Series.swaplevel"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23777,18 +32620,17 @@ ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[bui
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+None *(
+
+pct_change$pandas.core.series.Series.pct_change"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23815,30 +32657,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-i
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level *
-j
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level **
-copy
-
builtins.bool"
builtins.bool *.
-reorder_levels(pandas.core.series.Series.reorder_levels"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23865,18 +32692,46 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*+
+periods
+builtins.int"builtins.int */
+fill_method
+builtins.str"builtins.str *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+freq
+Any *
+kwargs
+Any*!
+first_valid_index+pandas.core.series.Series.first_valid_index"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23903,21 +32758,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*!
+last_valid_index*pandas.core.series.Series.last_valid_index"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*7
-order,
-builtins.list[Any]
-Any"
builtins.list*.
-explode!pandas.core.series.Series.explode"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23944,18 +32812,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*'
+	transpose#pandas.core.series.Series.transpose"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23982,20 +32847,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-unstack!pandas.core.series.Series.unstack":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24022,32 +32882,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level *
-
-fill_value
-pandas.core.resample.Resampler[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"pandas.core.resample.Resampler*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27277,87 +35320,30 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-rule
-Any*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *R
-closedD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *Q
-labelD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *
-
-convention
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str""pandas._typing.TimestampConvention *
-kind
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None *
-loffset
-Any *(
-base
-builtins.int"builtins.int *N
-onD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-origin
-Union[pandas._libs.tslibs.timestamps.Timestamp,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *
-offset
-AUnion[pandas._libs.tslibs.timedeltas.Timedelta,builtins.str,None]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
-builtins.str"builtins.str
-None *.
-firstpandas.core.series.Series.first"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27384,18 +35370,14 @@ AUnion[pandas._libs.tslibs.timedeltas.Timedelta,builtins.str,None]T
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27422,20 +35404,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-offset
-Any*.
-lastpandas.core.series.Series.last"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27462,18 +35438,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+__rpow__"pandas.core.series.Series.__rpow__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27500,23 +35473,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-offset
-Any* 
-rankpandas.core.series.Series.rank"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27543,51 +35507,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-method
-tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *2
-numeric_only
-
builtins.bool"
builtins.bool *
-	na_option
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str */
-	ascending
-
builtins.bool"
builtins.bool *)
-pct
-
builtins.bool"
builtins.bool *N
-wherepandas.core.series.Series.where"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27614,18 +35556,14 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27652,19 +35590,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-cond
-Union[pandas.core.series.Series[pandas._typing.S1],pandas.core.series.Series[builtins.bool],numpy.ndarray[Any,Any],CallableType[builtins.function],CallableType[builtins.function]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27691,49 +35624,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Seriese
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayK
-CallableType[builtins.function]&
-builtins.function"builtins.functionK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-other
-Any *-
-inplace
-
builtins.bool"
builtins.bool *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-try_cast
-
builtins.bool"
builtins.bool *e
-maskpandas.core.series.Series.mask"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*X
+__rsub__"pandas.core.series.Series.__rsub__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27760,18 +35661,29 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27798,51 +35710,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-cond
-TypeAlias[Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]]
-Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.list"pandas._typing.MaskType*)
-other)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,CallableType[builtins.function],pandas._libs.missing.NAType,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27869,43 +35744,14 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrameK
-CallableType[builtins.function]&
-builtins.function"builtins.function:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType
-None *-
-inplace
-
builtins.bool"
builtins.bool *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-try_cast
-
builtins.bool"
builtins.bool *0
-slice_shift%pandas.core.series.Series.slice_shift"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27932,18 +35778,17 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*X
+__rtruediv__&pandas.core.series.Series.__rtruediv__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27970,27 +35815,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *0
-tshift pandas.core.series.Series.tshift"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28017,18 +35864,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28055,29 +35898,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int *
-freq
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *4
-truncate"pandas.core.series.Series.truncate"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28104,18 +35932,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*X
+__truediv__%pandas.core.series.Series.__truediv__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28142,42 +35969,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-before
-3Union[datetime.date,builtins.str,builtins.int,None]
-
datetime.date"
datetime.date
-builtins.str"builtins.str
-builtins.int"builtins.int
-None *
-after
-3Union[datetime.date,builtins.str,builtins.int,None]
-
datetime.date"
datetime.date
-builtins.str"builtins.str
-builtins.int"builtins.int
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None **
-copy
-
builtins.bool"
builtins.bool *2
-
-tz_convert$pandas.core.series.Series.tz_convert"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28204,18 +36018,14 @@ tz_convert$pandas.core.series.Series.tz_convert"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28242,36 +36052,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-tz
-Any*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None **
-copy
-
builtins.bool"
builtins.bool *3
-tz_localize%pandas.core.series.Series.tz_localize"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28298,18 +36086,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+__invert__$pandas.core.series.Series.__invert__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28336,40 +36124,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-tz
-Any*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None **
-copy
-
builtins.bool"
builtins.bool *
-	ambiguous
-Any */
-nonexistent
-builtins.str"builtins.str *.
-abspandas.core.series.Series.abs"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+atpandas.core.series.Series.at"B
+pandas.core.indexing._AtIndexer"pandas.core.indexing._AtIndexer*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28396,18 +36161,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
+catpandas.core.series.Series.cat"h
+2pandas.core.arrays.categorical.CategoricalAccessor"2pandas.core.arrays.categorical.CategoricalAccessor*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28434,18 +36198,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*u
-describe"pandas.core.series.Series.describe"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
+iatpandas.core.series.Series.iat"D
+ pandas.core.indexing._iAtIndexer" pandas.core.indexing._iAtIndexer*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28472,18 +36235,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*'
+ilocpandas.core.series.Series.iloc"
+8pandas.core.series._iLocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28510,26 +36270,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-percentiles
-)Union[builtins.list[builtins.float],None]P
-builtins.list[builtins.float] 
-builtins.float"builtins.float"
builtins.list
-None *
-include
-BUnion[Literal[builtins.str],builtins.list[pandas._typing.S1],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"%pandas.core.series._iLocIndexerSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28556,19 +36305,15 @@ BUnion[Literal[builtins.str],builtins.list[pandas._typing.S1],None]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-None *-
-exclude-
->Union[pandas._typing.S1,builtins.list[pandas._typing.S1],None]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*'
+locpandas.core.series.Series.loc"
+7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28595,17 +36340,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"$pandas.core.series._LocIndexerSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28632,24 +36375,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-None *b
-datetime_is_numericG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None */
-
-pct_change$pandas.core.series.Series.pct_change"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*M
+addpandas.core.series.Series.add"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28676,18 +36410,15 @@ pct_change$pandas.core.series.Series.pct_change"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28714,49 +36445,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int */
-fill_method
-builtins.str"builtins.str *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-freq
-Any *
-kwargs
-Any*$
-first_valid_index+pandas.core.series.Series.first_valid_index"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28783,15 +36481,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$
-last_valid_index*pandas.core.series.Series.last_valid_index"
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -28809,11 +36503,27 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *(
+axis
+builtins.int"builtins.int *
+allpandas.core.series.Series.all"
+
builtins.bool"
builtins.bool*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28840,21 +36550,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-value_counts&pandas.core.series.Series.value_counts"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+anypandas.core.series.Series.any"
+
builtins.bool"
builtins.bool*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28881,30 +36602,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*/
-	normalize
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool */
-	ascending
-
builtins.bool"
builtins.bool *P
-binsD
-Union[builtins.int,None]
-builtins.int"builtins.int
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
 None *,
-dropna
-
builtins.bool"
builtins.bool *.
-	transpose#pandas.core.series.Series.transpose"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any**
+cummax pandas.core.series.Series.cummax"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28931,18 +36652,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28969,22 +36687,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
 args
 Any*
 kwargs
-Any*.
-Tpandas.core.series.Series.T"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any**
+cummin pandas.core.series.Series.cummin"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29011,18 +36737,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29049,18 +36772,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*P
-__div__!pandas.core.series.Series.__div__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+args
+Any*
+kwargs
+Any**
+cumprod!pandas.core.series.Series.cumprod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29087,18 +36822,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29125,39 +36857,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+args
+Any*
+kwargs
+Any**
+cumsum pandas.core.series.Series.cumsum"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29184,20 +36907,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-__eq__ pandas.core.series.Series.__eq__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29224,21 +36942,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$"
-builtins.object"builtins.object*:
-__floordiv__&pandas.core.series.Series.__floordiv__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+args
+Any*
+kwargs
+Any*]
+divide pandas.core.series.Series.divide"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29265,18 +36995,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -29287,16 +37015,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29322,21 +37044,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 Type[builtins.object]"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*Q
-__ge__ pandas.core.series.Series.__ge__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29363,17 +37079,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29400,36 +37113,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *p
+divmod pandas.core.series.Series.divmod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29456,22 +37167,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*Q
-__gt__ pandas.core.series.Series.__gt__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29498,17 +37202,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29535,36 +37252,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29591,22 +37286,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*Q
-__le__ pandas.core.series.Series.__le__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29633,17 +37320,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *=
+eqpandas.core.series.Series.eq"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29670,36 +37377,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29726,22 +37431,38 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*Q
-__lt__ pandas.core.series.Series.__lt__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+ewmpandas.core.series.Series.ewm"
+Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29768,17 +37489,41 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*U
+comJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *V
+spanJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *Z
+halflifeJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *W
+alphaJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None */
+min_periods
+builtins.int"builtins.int *,
+adjust
+
builtins.bool"
builtins.bool */
+	ignore_na
+
builtins.bool"
builtins.bool *
+	expanding#pandas.core.series.Series.expanding"
+Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29805,36 +37550,27 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*/
+min_periods
+builtins.int"builtins.int *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod *^
+floordiv"pandas.core.series.Series.floordiv"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29861,20 +37597,30 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*P
-__mod__!pandas.core.series.Series.__mod__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29901,17 +37647,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29938,38 +37681,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29996,20 +37715,39 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-__ne__ pandas.core.series.Series.__ne__"e
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *=
+gepandas.core.series.Series.ge"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30036,19 +37774,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$"
-builtins.object"builtins.object*P
-__pow__!pandas.core.series.Series.__pow__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30075,17 +37828,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *=
+gtpandas.core.series.Series.gt"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30112,38 +37885,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30170,18 +37939,33 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__radd__"pandas.core.series.Series.__radd__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *&
+itempandas.core.series.Series.item"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30208,17 +37992,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30245,39 +38027,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+kurtpandas.core.series.Series.kurt"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,builtins.str,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-builtins.str"builtins.str
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30304,18 +38081,51 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*%
+kurtosis"pandas.core.series.Series.kurtosis"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rdiv__"pandas.core.series.Series.__rdiv__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30342,17 +38152,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*=
+lepandas.core.series.Series.le"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30379,38 +38207,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30437,18 +38261,37 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rdivmod__%pandas.core.series.Series.__rdivmod__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *=
+ltpandas.core.series.Series.lt"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30475,18 +38318,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30513,39 +38372,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex **
+maxpandas.core.series.Series.max"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30572,18 +38425,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-
__rfloordiv__'pandas.core.series.Series.__rfloordiv__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30610,17 +38460,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+meanpandas.core.series.Series.mean" 
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30647,38 +38514,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+median pandas.core.series.Series.median" 
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30705,18 +38568,31 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rmod__"pandas.core.series.Series.__rmod__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any**
+minpandas.core.series.Series.min"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30743,17 +38619,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30780,38 +38654,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*q
+modpandas.core.series.Series.mod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30838,20 +38706,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*#
-__rmul__"pandas.core.series.Series.__rmul__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30878,18 +38741,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[Any]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -30900,19 +38761,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLikeD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*P
-__rnatmul__%pandas.core.series.Series.__rnatmul__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30939,18 +38791,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30977,39 +38825,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31036,18 +38859,36 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rpow__"pandas.core.series.Series.__rpow__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *q
+multiply"pandas.core.series.Series.multiply"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31074,17 +38915,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31111,18 +38950,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -31133,16 +38970,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31169,20 +39000,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*:
-__rsub__"pandas.core.series.Series.__rsub__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31209,38 +39034,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31267,20 +39068,39 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*:
-__truediv__%pandas.core.series.Series.__truediv__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *=
+nepandas.core.series.Series.ne"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31307,38 +39127,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31365,21 +39181,36 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
 
-__invert__$pandas.core.series.Series.__invert__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+nunique!pandas.core.series.Series.nunique"
+builtins.int"builtins.int*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31406,20 +39237,17 @@ __invert__$pandas.core.series.Series.__invert__"e
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-atpandas.core.series.Series.at"B
-pandas.core.indexing._AtIndexer"pandas.core.indexing._AtIndexer*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*,
+dropna
+
builtins.bool"
builtins.bool *q
+powpandas.core.series.Series.pow"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31446,20 +39274,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
-catpandas.core.series.Series.cat"h
-2pandas.core.arrays.categorical.CategoricalAccessor"2pandas.core.arrays.categorical.CategoricalAccessor*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31486,20 +39309,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
-iatpandas.core.series.Series.iat"D
- pandas.core.indexing._iAtIndexer" pandas.core.indexing._iAtIndexer*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31526,18 +39359,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*.
-ilocpandas.core.series.Series.iloc"
-8pandas.core.series._iLocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31564,18 +39393,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"%pandas.core.series._iLocIndexerSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31602,18 +39427,55 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *%
+prodpandas.core.series.Series.prod"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*.
-locpandas.core.series.Series.loc"
-7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31640,18 +39502,55 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *-
+	min_count
+builtins.int"builtins.int *
+kwargs
+Any*%
+product!pandas.core.series.Series.product"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"$pandas.core.series._LocIndexerSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31678,18 +39577,36 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*X
-addpandas.core.series.Series.add"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *-
+	min_count
+builtins.int"builtins.int *
+kwargs
+Any*O
+raddpandas.core.series.Series.radd"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31716,18 +39633,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31754,19 +39668,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31793,14 +39704,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -31830,15 +39738,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fill_valueJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *(
-axis
-builtins.int"builtins.int *
-allpandas.core.series.Series.all"
-
builtins.bool"
builtins.bool*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rdivmod!pandas.core.series.Series.rdivmod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31865,35 +39776,51 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any*
-anypandas.core.series.Series.any"
-
builtins.bool"
builtins.bool*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31920,33 +39847,52 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any*1
-cummax pandas.core.series.Series.cummax"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *,
+	rfloordiv#pandas.core.series.Series.rfloordiv"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31973,18 +39919,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32011,33 +39954,36 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+Any*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*1
-cummin pandas.core.series.Series.cummin"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rmodpandas.core.series.Series.rmod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32064,18 +40010,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32102,33 +40045,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*1
-cumprod!pandas.core.series.Series.cumprod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32155,18 +40081,52 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rpowpandas.core.series.Series.rpow"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32193,33 +40153,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*1
-cumsum pandas.core.series.Series.cumsum"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32246,18 +40188,16 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32284,36 +40224,52 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*?
-divide pandas.core.series.Series.divide"h
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rsubpandas.core.series.Series.rsub"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32340,39 +40296,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32399,37 +40331,16 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *U
-divmod pandas.core.series.Series.divmod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32456,18 +40367,52 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *,
+rtruediv"pandas.core.series.Series.rtruediv"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32494,39 +40439,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32553,14 +40474,13 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+Any*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -32579,14 +40499,30 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *D
-eqpandas.core.series.Series.eq"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *%
+sempandas.core.series.Series.sem"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32613,16 +40549,33 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *(
+ddof
+builtins.int"builtins.int *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*%
+skewpandas.core.series.Series.skew"
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -32640,10 +40593,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32670,41 +40624,36 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-ewmpandas.core.series.Series.ewm"
-Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+stdpandas.core.series.Series.std" 
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32731,51 +40680,36 @@ Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-comJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *V
-spanJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *Z
-halflifeJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *W
-alphaJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None */
-min_periods
-builtins.int"builtins.int *,
-adjust
-
builtins.bool"
builtins.bool */
-	ignore_na
-
builtins.bool"
builtins.bool *
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-	expanding#pandas.core.series.Series.expanding"
-Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *(
+ddof
+builtins.int"builtins.int *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*q
+subpandas.core.series.Series.sub"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32802,37 +40736,15 @@ Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*/
-min_periods
-builtins.int"builtins.int *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod *@
-floordiv"pandas.core.series.Series.floordiv"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32859,19 +40771,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -32882,16 +40791,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32918,42 +40821,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *D
-gepandas.core.series.Series.ge"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32980,37 +40855,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33037,14 +40889,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -33056,21 +40905,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fill_valueJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *
-axis
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *D
-gtpandas.core.series.Series.gt"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *q
+subtract"pandas.core.series.Series.subtract"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33097,37 +40945,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33154,36 +40980,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-itempandas.core.series.Series.item"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33210,18 +41030,14 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33248,37 +41064,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*(
-kurtpandas.core.series.Series.kurt"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33305,88 +41098,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*(
-kurtosis"pandas.core.series.Series.kurtosis"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
 
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -33395,22 +41123,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*D
-lepandas.core.series.Series.le"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *&
+to_list!pandas.core.series.Series.to_list"
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33437,37 +41154,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33487,47 +41182,26 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Type[builtins.str]
 builtins.str"builtins.str"typeF
 Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *D
-ltpandas.core.series.Series.lt"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*.
+to_numpy"pandas.core.series.Series.to_numpy"9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33554,16 +41228,38 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+Union[TypeAlias[Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]]],None]
+
+TypeAlias[Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]]]
+Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]](
+numpy.dtype[Any]
+Any"numpy.dtype
+None
+
builtins.type"
builtins.type
+:numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]](
+numpy.dtype[Any]
+Any"numpy.dtype"(numpy._typing._dtype_like._SupportsDType
+builtins.str"builtins.str
+lTypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]
+aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]
+"Tuple[TypeAlias[Any],builtins.int]G
+TypeAlias[Any]
+Any"*numpy._typing._dtype_like._DTypeLikeNested
+builtins.int"builtins.int,
+builtins.list[Any]
+Any"
builtins.listM
+TypeAlias[TypedDict]
+	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike
+None **
+copy
+
builtins.bool"
builtins.bool *
+na_value
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -33581,10 +41277,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar *
+kwargs
+Any*&
+tolist pandas.core.series.Series.tolist"
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33611,36 +41310,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *1
-maxpandas.core.series.Series.max"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33667,18 +41345,18 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+truediv!pandas.core.series.Series.truediv"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33705,94 +41383,55 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+Any*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*
-meanpandas.core.series.Series.mean" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *%
+varpandas.core.series.Series.var"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+
datetime.date"
datetime.date&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*
-median pandas.core.series.Series.median" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33819,14 +41458,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -33835,18 +41471,24 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
 level
-None *2
+None *(
+ddof
+builtins.int"builtins.int *2
 numeric_only
 
builtins.bool"
builtins.bool *
 kwargs
-Any*1
-minpandas.core.series.Series.min"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*/
+set_axis"pandas.core.series.Series.set_axis"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33873,18 +41515,16 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33911,35 +41551,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+labels
+Any*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*V
-modpandas.core.series.Series.mod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis **
+copy
+
builtins.bool"
builtins.bool *&
+__iter__"pandas.core.series.Series.__iter__"
+"typing.Iterator[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33966,18 +41605,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterator*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34004,39 +41639,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*-
+xspandas.core.series.Series.xs"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34063,39 +41675,16 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *V
-mulpandas.core.series.Series.mul"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34122,18 +41711,39 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*+
+key"
+typing.Hashable"typing.Hashable*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *0
+
+drop_level
+
builtins.bool"
builtins.bool 2
+__new__!pandas.core.series.Series.__new__,
+__new__!pandas.core.series.Series.__new__"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34160,47 +41770,43 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*
+
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
 builtins.list[Any]
-Any"
builtins.list.
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
 builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
+Any"builtins.tuple"pandas._typing.Axes
+None *	
+dtype	
 TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
 Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
 &pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
@@ -34216,42 +41822,18 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 Type[builtins.bool]
 
builtins.bool"
builtins.bool"typeC
 Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *V
-multiply"pandas.core.series.Series.multiply"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadXO
+__new__!pandas.core.series.Series.__new__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34278,18 +41860,163 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+Union[pandas.core.indexes.datetimes.DatetimeIndex,typing.Sequence[Union[numpy.datetime64,datetime.datetime,datetime.date]],builtins.dict[pandas._typing.HashableT1,Union[numpy.datetime64,datetime.datetime,datetime.date]],numpy.datetime64,datetime.datetime,datetime.date]Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex
+Htyping.Sequence[Union[numpy.datetime64,datetime.datetime,datetime.date]]
+7Union[numpy.datetime64,datetime.datetime,datetime.date]$
+numpy.datetime64"numpy.datetime64&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date"typing.Sequence
+`builtins.dict[pandas._typing.HashableT1,Union[numpy.datetime64,datetime.datetime,datetime.date]]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable
+7Union[numpy.datetime64,datetime.datetime,datetime.date]$
+numpy.datetime64"numpy.datetime64&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date"
builtins.dict$
+numpy.datetime64"numpy.datetime64&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date*
+
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *&
+dtype&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadXt
+__new__!pandas.core.series.Series.__new__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34316,19 +42043,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*.
+data.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -34339,16 +42061,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34375,42 +42091,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *D
-nepandas.core.series.Series.ne"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34437,174 +42125,145 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike*
 
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
+index
 
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *&
+dtype&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-nunique!pandas.core.series.Series.nunique"
-builtins.int"builtins.int*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*,
-dropna
-
builtins.bool"
builtins.bool *V
-powpandas.core.series.Series.pow"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg*.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadX#
+__new__!pandas.core.series.Series.__new__"B
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34631,39 +42290,53 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+`Union[pandas.core.indexes.period.PeriodIndex,typing.Sequence[pandas._libs.tslibs.period.Period]]P
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex
+2typing.Sequence[pandas._libs.tslibs.period.Period]F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period"typing.Sequence*
+
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
 builtins.list[Any]
-Any"
builtins.list.
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
 builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"builtins.tuple"pandas._typing.Axes
+None *[
+dtypeN
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadXL
+__new__!pandas.core.series.Series.__new__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34690,58 +42363,162 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+Union[pandas.core.indexes.timedeltas.TimedeltaIndex,typing.Sequence[Union[numpy.timedelta64,datetime.timedelta]],builtins.dict[pandas._typing.HashableT1,Union[numpy.timedelta64,datetime.timedelta]],numpy.timedelta64,datetime.timedelta]^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex
+
-sort_values%pandas.core.series.Series.sort_values"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX:
+rename pandas.core.series.Series.rename"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42122,18 +49203,16 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42160,15 +49239,26 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+index
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -42182,45 +49272,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX?
-sort_values%pandas.core.series.Series.sort_values"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX6
+rename pandas.core.series.Series.rename"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42247,19 +49324,16 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42286,15 +49360,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*Z
+indexM
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -42308,50 +49384,36 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2
-
-sort_index$pandas.core.series.Series.sort_index*
-
-sort_index$pandas.core.series.Series.sort_index"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX'
+rename pandas.core.series.Series.rename"~
+*Union[pandas.core.series.Series[Any],None]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42378,15 +49440,27 @@ sort_index$pandas.core.series.Series.sort_index"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+index
+Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer"
+typing.Hashable"typing.Hashable
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -42400,57 +49474,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *-
+inplace
+
builtins.bool"
builtins.bool *
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
 builtins.int"builtins.int"pandas._typing.Level
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
+None *
+errors
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX,
-
-sort_index$pandas.core.series.Series.sort_index"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
+fillna pandas.core.series.Series.fillna>
+fillna pandas.core.series.Series.fillna"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42477,85 +49527,188 @@ sort_index$pandas.core.series.Series.sort_index"D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+value%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *I
+builtins.int"builtins.int"pandas._typing.AxisIndex *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX-
-
-sort_index$pandas.core.series.Series.sort_index"~
-*Union[pandas.core.series.Series[Any],None]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool0:typing.overloadXQ
+fillna pandas.core.series.Series.fillna"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+value%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42582,80 +49735,38 @@ sort_index$pandas.core.series.Series.sort_index"~
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2l
-	aggregate#pandas.core.series.Series.aggregate2
-	aggregate#pandas.core.series.Series.aggregate"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadXQ
+fillna pandas.core.series.Series.fillna"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42682,18 +49793,16 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42720,36 +49829,38 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+value%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX9
-	aggregate#pandas.core.series.Series.aggregate"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42776,18 +49887,37 @@ JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *-
+inplace
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2
+replace!pandas.core.series.Series.replaceS
+replace!pandas.core.series.Series.replace"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42814,44 +49944,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-TypeAlias[Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]]
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
-0typing.Mapping[pandas._typing.HashableT,Unknown]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries"'pandas._typing.AggFuncTypeSeriesToFrame *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX2V
-	transform#pandas.core.series.Series.transform3
-	transform#pandas.core.series.Series.transform"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42878,18 +49979,23 @@ JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+to_replace
+~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
+builtins.str"builtins.str,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42916,38 +50022,65 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series 
+builtins.float"builtins.float
+None *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict,
+builtins.list[Any]
+Any"
builtins.list
+builtins.str"builtins.str
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX"
-	transform#pandas.core.series.Series.transform":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX@
+replace!pandas.core.series.Series.replace"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42974,48 +50107,23 @@ JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX23
-applypandas.core.series.Series.apply
-applypandas.core.series.Series.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+to_replace
+~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
+builtins.str"builtins.str,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43042,30 +50150,64 @@ Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series 
+builtins.float"builtins.float
+None *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*2
-convertDType
-
builtins.bool"
builtins.bool *:
-args.
-builtins.tuple[Any]
-Any"builtins.tuple *
-kwds
-Any0:typing.overloadX
-applypandas.core.series.Series.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict,
+builtins.list[Any]
+Any"
builtins.list
+builtins.str"builtins.str
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadXT
+replace!pandas.core.series.Series.replace"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43092,31 +50234,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*2
-convertDType
-
builtins.bool"
builtins.bool *:
-args.
-builtins.tuple[Any]
-Any"builtins.tuple *
-kwds
-Any0:typing.overloadX2
-rename pandas.core.series.Series.rename*
-rename pandas.core.series.Series.rename"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43143,71 +50270,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-index
-Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
-lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
-aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
-:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
-Any
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label"typing.MappingK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Renamer"
-typing.Hashable"typing.Hashable
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX*
-rename pandas.core.series.Series.rename"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+to_replace
+~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
+builtins.str"builtins.str,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43234,70 +50313,65 @@ aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[b
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series 
+builtins.float"builtins.float
+None *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-index
-xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
-lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
-aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
-:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
-Any
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label"typing.MappingK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Renamer
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict,
+builtins.list[Any]
+Any"
builtins.list
+builtins.str"builtins.str
+None *-
+inplace
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX%
-rename pandas.core.series.Series.rename"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX2o
+dropna pandas.core.series.Series.dropna
+dropna pandas.core.series.Series.dropna"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43324,63 +50398,32 @@ aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[b
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*Z
-indexM
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *I
+builtins.int"builtins.int"pandas._typing.AxisIndex *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+
builtins.bool"
builtins.bool*
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX+
-rename pandas.core.series.Series.rename"~
-*Union[pandas.core.series.Series[Any],None]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str
+None 0:typing.overloadX+
+dropna pandas.core.series.Series.dropna"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43407,70 +50450,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-index
-Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
-lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
-aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
-:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
-Any
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label"typing.MappingK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Renamer"
-typing.Hashable"typing.Hashable
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *-
-inplace
-
builtins.bool"
builtins.bool *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
-droppandas.core.series.Series.drop+
-droppandas.core.series.Series.drop"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43497,77 +50485,33 @@ aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[b
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT2],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT2]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-columns
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT3]R
-pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *G
+builtins.int"builtins.int"pandas._typing.AxisIndex *I
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+
builtins.bool"
builtins.bool *
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX,
-droppandas.core.series.Series.drop"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str
+None 0:typing.overloadX+
+dropna pandas.core.series.Series.dropna"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43594,79 +50538,16 @@ cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.inde
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT2],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT2]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-columns
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT3]R
-pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX,
-droppandas.core.series.Series.drop"~
-*Union[pandas.core.series.Series[Any],None]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43693,76 +50574,35 @@ cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.inde
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT2],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT2]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-columns
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT3]R
-pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *-
+builtins.int"builtins.int"pandas._typing.AxisIndex *-
 inplace
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+
builtins.bool"
builtins.bool *
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
-fillna pandas.core.series.Series.fillnaI
-fillna pandas.core.series.Series.fillna"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str
+None 0:typing.overloadX2
+astype pandas.core.series.Series.astype 
+astype pandas.core.series.Series.astype"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43789,41 +50629,49 @@ cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.inde
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
-value)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXs
+astype pandas.core.series.Series.astype"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43850,20 +50698,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None *
-method
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*[
+dtype[
+Union[TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]]&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -43871,32 +50722,163 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX`
-fillna pandas.core.series.Series.fillna"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX 
+astype pandas.core.series.Series.astype"b
+'pandas.core.series.Series[builtins.str]
+builtins.str"builtins.str"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43923,79 +50905,53 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*	
+dtype	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
 Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
-value)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
 
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+astype pandas.core.series.Series.astype"h
+)pandas.core.series.Series[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44022,20 +50978,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None *
-method
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -44043,33 +50999,25 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadXa
-fillna pandas.core.series.Series.fillna"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX5
+astype pandas.core.series.Series.astype"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44096,19 +51044,98 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+$Type[numpy.floating[TypeAlias[Any]]]l
+numpy.floating[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitHalf"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX,
+astype pandas.core.series.Series.astype"n
++pandas.core.series.Series[builtins.complex]$
+builtins.complex"builtins.complex"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44135,81 +51162,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
-value)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
 Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None *
-method
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str
+3Type[numpy.complexfloating[TypeAlias[Any],Unknown]]
+-numpy.complexfloating[TypeAlias[Any],Unknown]<
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitSingle"numpy.complexfloating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -44217,70 +51185,52 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-inplace
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2
-replace!pandas.core.series.Series.replace^
-replace!pandas.core.series.Series.replace"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX;
+astype pandas.core.series.Series.astype"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44307,26 +51257,121 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-to_replace
-~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
-builtins.str"builtins.str,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*$
+dtype$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX=
+astype pandas.core.series.Series.astype"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44353,68 +51398,126 @@ to_replace
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series 
-builtins.float"builtins.float
-None *
-value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list
-builtins.str"builtins.str
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-regex
-Any *
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*&
+dtype&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadXG
-replace!pandas.core.series.Series.replace"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+astype pandas.core.series.Series.astype"
+Epandas.core.series.Series[pandas.core.dtypes.dtypes.CategoricalDtype]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44441,26 +51544,33 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-to_replace
-~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
-builtins.str"builtins.str,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX$
+astype pandas.core.series.Series.astype"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44487,106 +51597,57 @@ to_replace
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series 
-builtins.float"builtins.float
-None *
-value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+Union[TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
 
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list
-builtins.str"builtins.str
-None *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-regex
-Any *
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+numpy.void"
+numpy.void"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ReplaceMethod *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX^
-replace!pandas.core.series.Series.replace"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
+builtins.str"builtins.str"pandas._typing.VoidDtypeArgP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2E
+ffillpandas.core.series.Series.ffill
+ffillpandas.core.series.Series.ffill"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44613,26 +51674,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-to_replace
-~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
-builtins.str"builtins.str,
-builtins.list[Any]
-Any"
builtins.list9
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
 builtins.dict[Any,Any]
 Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
builtins.dict
+None 0:typing.overloadX,
+ffillpandas.core.series.Series.ffill"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44659,68 +51731,15 @@ to_replace
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series 
-builtins.float"builtins.float
-None *
-value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list
-builtins.str"builtins.str
-None *-
-inplace
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-regex
-Any *
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX2
-dropna pandas.core.series.Series.dropna
-dropna pandas.core.series.Series.dropna"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44747,73 +51766,40 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *G
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *I
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-how
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None 0:typing.overloadX2
-dropna pandas.core.series.Series.dropna"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2ř
+bfillpandas.core.series.Series.bfill
+bfillpandas.core.series.Series.bfill"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44840,36 +51826,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *I
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-how
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None 0:typing.overloadX2
-dropna pandas.core.series.Series.dropna"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX,
+bfillpandas.core.series.Series.bfill"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44896,19 +51883,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44935,38 +51918,38 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-inplace
-
builtins.bool"
builtins.bool *
-how
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None 0:typing.overloadX2֔
-astype pandas.core.series.Series.astype$
-astype pandas.core.series.Series.astype"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadXS
+bfillpandas.core.series.Series.bfill"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44993,54 +51976,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*	
-dtype	
-TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"type7
-Literal[builtins.str]	
-builtins.str"builtins.strR
-'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Type[numpy.bool_]
-numpy.bool_"numpy.bool_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.BooleanDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXx
-astype pandas.core.series.Series.astype"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45067,194 +52012,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*]
-dtype]
-Union[TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]]'
-TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
-Type[builtins.int]
-builtins.int"builtins.int"type7
-Literal[builtins.str]	
-builtins.str"builtins.strL
-$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
-%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
-%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
-%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-)Type[numpy.signedinteger[TypeAlias[Any]]]v
-#numpy.signedinteger[TypeAlias[Any]]:
-TypeAlias[Any]
-Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IntDtypeArg%
-TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
-%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
-&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
-&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
-&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.UIntDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX$
-astype pandas.core.series.Series.astype"b
-'pandas.core.series.Series[builtins.str]
-builtins.str"builtins.str"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*'
+value'
+xUnion[pandas._typing.S1,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45281,56 +52047,17 @@ $Type[numpy.unsignedinteger[Unknown]]9
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*	
-dtype	
-TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
-Type[builtins.str]
-builtins.str"builtins.str"type7
-Literal[builtins.str]	
-builtins.str"builtins.strP
-&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
-Literal[builtins.str]	
-builtins.str"builtins.str4
-Type[numpy.str_]
-
-numpy.str_"
-numpy.str_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.StrDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX"
-astype pandas.core.series.Series.astype"h
-)pandas.core.series.Series[builtins.bytes] 
-builtins.bytes"builtins.bytes"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45357,51 +52084,39 @@ numpy.str_"type7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
-Type[builtins.bytes] 
-builtins.bytes"builtins.bytes"type7
-Literal[builtins.str]	
-builtins.str"builtins.str:
-Type[numpy.bytes_]
-numpy.bytes_"numpy.bytes_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.BytesDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX9
-astype pandas.core.series.Series.astype"h
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *-
+inplace
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2.
+value_counts&pandas.core.series.Series.value_counts
+value_counts&pandas.core.series.Series.value_counts"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45428,101 +52143,31 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
-Type[builtins.float] 
-builtins.float"builtins.float"type7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
-(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-$Type[numpy.floating[TypeAlias[Any]]]l
-numpy.floating[TypeAlias[Any]]:
-TypeAlias[Any]
-Any"numpy._typing._nbit._NBitHalf"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-Type[numpy.floating[Unknown]]+
-numpy.floating[Unknown]"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-Type[numpy.floating[Unknown]]+
-numpy.floating[Unknown]"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-Type[numpy.floating[Unknown]]+
-numpy.floating[Unknown]"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FloatDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX0
-astype pandas.core.series.Series.astype"n
-+pandas.core.series.Series[builtins.complex]$
-builtins.complex"builtins.complex"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*K
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *P
+binsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+value_counts&pandas.core.series.Series.value_counts"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45549,78 +52194,65 @@ $Type[numpy.floating[TypeAlias[Any]]]l
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*I
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool**
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *P
+binsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX2ϗ
+__add__!pandas.core.series.Series.__add__O
+__add__!pandas.core.series.Series.__add__"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type7
-Literal[builtins.str]	
-builtins.str"builtins.str
-3Type[numpy.complexfloating[TypeAlias[Any],Unknown]]
--numpy.complexfloating[TypeAlias[Any],Unknown]<
-TypeAlias[Any]
-Any"numpy._typing._nbit._NBitSingle"numpy.complexfloating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str{
-,Type[numpy.complexfloating[Unknown,Unknown]]C
-&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str{
-,Type[numpy.complexfloating[Unknown,Unknown]]C
-&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ComplexDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX?
-astype pandas.core.series.Series.astype"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45647,124 +52279,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$
-dtype$
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXA
-astype pandas.core.series.Series.astype"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*'&
+7Union[pandas._typing.S1,pandas.core.series.Series.Self]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45791,129 +52313,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*&
-dtype&
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.TimestampDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
-astype pandas.core.series.Series.astype"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45940,36 +52348,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
-GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.CategoryDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX(
-astype pandas.core.series.Series.astype"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(0:typing.overloadXH
+__add__!pandas.core.series.Series.__add__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45996,60 +52385,32 @@ GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-Union[TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
-gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
-\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
-Type[builtins.object]"
-builtins.object"builtins.object"type7
-Literal[builtins.str]	
-builtins.str"builtins.str=
-Type[numpy.object_]
-
numpy.object_"
numpy.object_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
-dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
-Type[numpy.void]
-
-numpy.void"
-numpy.void"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.VoidDtypeArgP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
-HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtypeP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2P
-ffillpandas.core.series.Series.ffill
-ffillpandas.core.series.Series.ffill"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*33
+Union[builtins.complex,builtins.str,datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any],numpy.timedelta64]$
+builtins.complex"builtins.complex
+builtins.str"builtins.str(
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46076,40 +52437,14 @@ HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX3
-ffillpandas.core.series.Series.ffill"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46136,18 +52471,21 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series&
+numpy.timedelta64"numpy.timedelta640:typing.overloadX28
+__and__!pandas.core.series.Series.__and__
+__and__!pandas.core.series.Series.__and__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46174,43 +52512,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2IJ
-bfillpandas.core.series.Series.bfill
-bfillpandas.core.series.Series.bfill"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
+
builtins.bool"
builtins.boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.listJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__and__!pandas.core.series.Series.__and__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46237,40 +52564,28 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX3
-bfillpandas.core.series.Series.bfill"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2]
+__mul__!pandas.core.series.Series.__mul__
+__mul__!pandas.core.series.Series.__mul__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46297,18 +52612,22 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta640:typing.overloadXE
+__mul__!pandas.core.series.Series.__mul__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46335,41 +52654,63 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
 Any
-Any"
builtins.dict
-None 0:typing.overloadXb
-bfillpandas.core.series.Series.bfill"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46396,19 +52737,20 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__or__ pandas.core.series.Series.__or__
+__or__ pandas.core.series.Series.__or__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46435,18 +52777,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*/
-value/
-xUnion[pandas._typing.S1,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
+
builtins.bool"
builtins.boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.listJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__or__ pandas.core.series.Series.__or__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46473,20 +52829,28 @@ xUnion[pandas._typing.S1,builtins.dict[Any,Any],pandas.core.series.Series[pandas
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2
+__radd__"pandas.core.series.Series.__radd__N
+__radd__"pandas.core.series.Series.__radd__"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46513,40 +52877,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-inplace
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2φ
-__add__!pandas.core.series.Series.__add__
-__add__!pandas.core.series.Series.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46573,20 +52912,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*JH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadX
-__add__!pandas.core.series.Series.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*&&
+EUnion[pandas._typing.S1,pandas.core.series.Series[pandas._typing.S1]]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46613,20 +52946,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
-__add__!pandas.core.series.Series.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46653,21 +52980,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*VT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:typing.overloadX<
-__add__!pandas.core.series.Series.__add__"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:typing.overloadXF
+__radd__"pandas.core.series.Series.__radd__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46694,20 +53017,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$$
-Union[builtins.complex,builtins.str,pandas._libs.tslibs.timedeltas.Timedelta,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],numpy.timedelta64]$
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,builtins.str,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
 builtins.complex"builtins.complex
-builtins.str"builtins.strT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+builtins.str"builtins.str.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -46718,16 +53037,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46754,22 +53067,54 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX2?
-__and__!pandas.core.series.Series.__and__ 
-__and__!pandas.core.series.Series.__and__"e
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__rand__"pandas.core.series.Series.__rand__
+__rand__"pandas.core.series.Series.__rand__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46796,14 +53141,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
 
builtins.bool"
builtins.boolM
 builtins.list[builtins.bool]
@@ -46818,13 +53160,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__and__!pandas.core.series.Series.__and__"b
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__rand__"pandas.core.series.Series.__rand__"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46851,14 +53193,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
 builtins.int"builtins.int
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -46869,13 +53208,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2>
-__mul__!pandas.core.series.Series.__mul__
-__mul__!pandas.core.series.Series.__mul__"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2]
+__rmul__"pandas.core.series.Series.__rmul__
+__rmul__"pandas.core.series.Series.__rmul__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46902,24 +53241,22 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64]T
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX$
-__mul__!pandas.core.series.Series.__mul__"D
+numpy.timedelta64"numpy.timedelta640:typing.overloadXE
+__rmul__"pandas.core.series.Series.__rmul__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46946,18 +53283,15 @@ dUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeri
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[Any]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -46968,22 +53302,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLikeD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series0:typing.overloadX2?
-__or__ pandas.core.series.Series.__or__ 
-__or__ pandas.core.series.Series.__or__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47010,35 +53332,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
-
builtins.bool"
builtins.boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.listJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__or__ pandas.core.series.Series.__or__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47065,32 +53366,20 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2?
-__rand__"pandas.core.series.Series.__rand__ 
-__rand__"pandas.core.series.Series.__rand__"e
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__ror__!pandas.core.series.Series.__ror__
+__ror__!pandas.core.series.Series.__ror__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47117,14 +53406,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
 
builtins.bool"
builtins.boolM
 builtins.list[builtins.bool]
@@ -47139,13 +53425,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__rand__"pandas.core.series.Series.__rand__"b
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__ror__!pandas.core.series.Series.__ror__"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47172,14 +53458,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
 builtins.int"builtins.int
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -47190,14 +53473,14 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2?
-__ror__!pandas.core.series.Series.__ror__ 
-__ror__!pandas.core.series.Series.__ror__"e
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX28
+__rxor__"pandas.core.series.Series.__rxor__
+__rxor__"pandas.core.series.Series.__rxor__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47224,14 +53507,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
 
builtins.bool"
builtins.boolM
 builtins.list[builtins.bool]
@@ -47246,13 +53526,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__ror__!pandas.core.series.Series.__ror__"b
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__rxor__"pandas.core.series.Series.__rxor__"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47279,14 +53559,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
 builtins.int"builtins.int
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -47297,14 +53574,31 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2S
-__rtruediv__&pandas.core.series.Series.__rtruediv__
-__rtruediv__&pandas.core.series.Series.__rtruediv__"h
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2i
+__sub__!pandas.core.series.Series.__sub__
+__sub__!pandas.core.series.Series.__sub__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+Cpandas.core.series.Series[pandas._libs.tslibs.timestamps.Timestamp]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas.core.series.Series*
+Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
+__sub__!pandas.core.series.Series.__sub__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series*
+Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
+__sub__!pandas.core.series.Series.__sub__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47331,21 +53625,21 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX:
-__rtruediv__&pandas.core.series.Series.__rtruediv__"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.series.TimestampSeries]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp&
+datetime.datetime"datetime.datetimeH
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadXE
+__sub__!pandas.core.series.Series.__sub__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47372,18 +53666,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -47394,16 +53685,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47430,21 +53715,54 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:typing.overloadX2?
-__rxor__"pandas.core.series.Series.__rxor__ 
-__rxor__"pandas.core.series.Series.__rxor__"e
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__xor__!pandas.core.series.Series.__xor__
+__xor__!pandas.core.series.Series.__xor__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47471,14 +53789,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
 
builtins.bool"
builtins.boolM
 builtins.list[builtins.bool]
@@ -47493,13 +53808,211 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__rxor__"pandas.core.series.Series.__rxor__"b
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__xor__!pandas.core.series.Series.__xor__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2i
+mulpandas.core.series.Series.mul
+mulpandas.core.series.Series.mul"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta64*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None 0:typing.overloadXK
+mulpandas.core.series.Series.mul"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*1
+other1
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47526,49 +54039,41 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2K
-__sub__!pandas.core.series.Series.__sub__
-__sub__!pandas.core.series.Series.__sub__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-Cpandas.core.series.Series[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas.core.series.Series*
-Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
-__sub__!pandas.core.series.Series.__sub__"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series*
-Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
-__sub__!pandas.core.series.Series.__sub__"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None 0:typing.overloadX2g
+rmulpandas.core.series.Series.rmul
+rmulpandas.core.series.Series.rmul"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47595,24 +54100,43 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.series.TimestampSeries]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp&
-datetime.datetime"datetime.datetimeH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadX$
-__sub__!pandas.core.series.Series.__sub__"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta64*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex 0:typing.overloadXJ
+rmulpandas.core.series.Series.rmul"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47639,18 +54163,16 @@ dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.se
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[Any]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*1
+other1
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -47661,22 +54183,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLikeD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series0:typing.overloadX2?
-__xor__!pandas.core.series.Series.__xor__ 
-__xor__!pandas.core.series.Series.__xor__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47703,35 +54213,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
-
builtins.bool"
builtins.boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.listJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__xor__!pandas.core.series.Series.__xor__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47758,34 +54247,41 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2P
-rolling!pandas.core.series.Series.rolling'
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex 0:typing.overloadX2D
+rolling!pandas.core.series.Series.rolling"
 rolling!pandas.core.series.Series.rolling"
 Apandas.core.window.rolling.Window[pandas.core.series.Series[Any]]D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"!pandas.core.window.rolling.Window*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series"!pandas.core.window.rolling.Window*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47812,14 +54308,11 @@ Apandas.core.window.rolling.Window[pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 window
 {Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
 builtins.int"builtins.int
@@ -47836,14 +54329,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 onD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
+None *
 closed
 uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
@@ -47869,15 +54355,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str" pandas._typing.CalculationMethod **
 win_type
-builtins.str"builtins.str0:typing.overloadX'
+builtins.str"builtins.str0:typing.overloadX"
 rolling!pandas.core.series.Series.rolling"
 Bpandas.core.window.rolling.Rolling[pandas.core.series.Series[Any]]D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series""pandas.core.window.rolling.Rolling*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series""pandas.core.window.rolling.Rolling*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47904,14 +54390,11 @@ Bpandas.core.window.rolling.Rolling[pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 window
 {Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
 builtins.int"builtins.int
@@ -47928,14 +54411,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 onD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
+None *
 closed
 uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
@@ -47961,7 +54437,7 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str" pandas._typing.CalculationMethod *
 win_type
-None 0:typing.overloadX2>
+None 0:typing.overloadX27
 sumpandas.core.series.Series.sum
 sumpandas.core.series.Series.sum"
 Any*X
@@ -48015,10 +54491,10 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 	min_count
 builtins.int"builtins.int *
 kwargs
-Any0:typing.overloadX2
-sumpandas.core.series.Series.sum"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any0:typing.overloadX+
+sumpandas.core.series.Series.sum"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48045,18 +54521,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48083,14 +54556,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -48111,14 +54581,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 	min_count
 builtins.int"builtins.int *
 kwargs
-Any0:typing.overloadX2΢
-rename_axis%pandas.core.series.Series.rename_axisP
+Any0:typing.overloadX2
+rename_axis%pandas.core.series.Series.rename_axisM
 rename_axis%pandas.core.series.Series.rename_axis"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48145,14 +54615,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 mapper
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._typing.ListLike]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -48244,14 +54711,12 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 
builtins.bool"
builtins.bool *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadXQ
-rename_axis%pandas.core.series.Series.rename_axis"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool0:typing.overloadXa
+rename_axis%pandas.core.series.Series.rename_axis"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48278,14 +54743,47 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
 mapper
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._typing.ListLike]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -48816,8 +55314,8 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 __radd__*pandas._libs.tslibs.period.Period.__radd__"J
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*HF
 !pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*LJ
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
-	Timedelta(pandas._libs.tslibs.timedeltas.Timedelta"datetime.timedelta*5
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
+	Timedelta(pandas._libs.tslibs.timedeltas.Timedelta"datetime.timedelta*-
 __new__0pandas._libs.tslibs.timedeltas.Timedelta.__new__"
 -pandas._libs.tslibs.timedeltas.Timedelta.SelfT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
@@ -48831,30 +55329,10 @@ nUnion[builtins.str,builtins.int,pandas._libs.tslibs.timedeltas.Timedelta,dateti
 builtins.int"builtins.intT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
 datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64 *#
-unit#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+numpy.timedelta64"numpy.timedelta64 *
+unit
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -49112,7 +55590,39 @@ aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[T
 builtins.list[Any]
 Any"
builtins.listM
 TypeAlias[TypedDict]
-	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike 2+
+	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike *
+unit-pandas._libs.tslibs.timedeltas.Timedelta.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*^
+selfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta0:builtins.property`*
+as_unit0pandas._libs.tslibs.timedeltas.Timedelta.as_unit"
+-pandas._libs.tslibs.timedeltas.Timedelta.SelfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
+self
+-pandas._libs.tslibs.timedeltas.Timedelta.SelfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool 2+
 __add__0pandas._libs.tslibs.timedeltas.Timedelta.__add__
 __add__0pandas._libs.tslibs.timedeltas.Timedelta.__add__"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*VT
@@ -49276,7 +55786,7 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 mUnion[pandas.core.series.TimedeltaSeries,pandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]]H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries
 Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series0:typing.overloadX2$
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series0:typing.overloadX2$
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*VT
@@ -49284,11 +55794,12 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 TUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedelta64](
 datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"T
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*VT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
-@Union[pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
+RUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp$
 numpy.datetime64"numpy.datetime640:typing.overloadX
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"J
@@ -49815,7 +56326,7 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 resolution3pandas._libs.tslibs.timedeltas.Timedelta.resolutionT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltarU
 value.pandas._libs.tslibs.timedeltas.Timedelta.value
-builtins.int"builtins.intю
+builtins.int"builtins.int
 	Timestamp(pandas._libs.tslibs.timestamps.Timestamp"datetime.datetime*
 __new__0pandas._libs.tslibs.timestamps.Timestamp.__new__"
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
@@ -50012,12 +56523,14 @@ nanosecond3pandas._libs.tslibs.timestamps.Timestamp.nanosecond"
 cls
 3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
-combine0pandas._libs.tslibs.timestamps.Timestamp.combine"&
-datetime.datetime"datetime.datetime*
-cls
-.Type[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"type*(
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
+combine0pandas._libs.tslibs.timestamps.Timestamp.combine"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+cls
+3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type*(
 date
 
datetime.date"
datetime.date*(
 time
@@ -50200,13 +56713,9 @@ astimezone3pandas._libs.tslibs.timestamps.Timestamp.astimezone"
 isoweekday3pandas._libs.tslibs.timestamps.Timestamp.isoweekday"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
-isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
-8TypeAlias[Tuple[builtins.int,builtins.int,builtins.int]]
--Tuple[builtins.int,builtins.int,builtins.int]
-builtins.int"builtins.int
-builtins.int"builtins.int
-builtins.int"builtins.int"/pandas._libs.tslibs.timestamps._IsoCalendarDate*^
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
+isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
+Any*^
 selfT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
 is_leap_year5pandas._libs.tslibs.timestamps.Timestamp.is_leap_year"
@@ -50460,7 +56969,39 @@ weekofyear3pandas._libs.tslibs.timestamps.Timestamp.weekofyear"
 daysinmonth4pandas._libs.tslibs.timestamps.Timestamp.daysinmonth"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`2
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+unit-pandas._libs.tslibs.timestamps.Timestamp.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*^
+selfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+as_unit0pandas._libs.tslibs.timestamps.Timestamp.as_unit"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+self
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool 2
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__"
 
builtins.bool"
builtins.bool*VT
@@ -50864,16 +57405,17 @@ aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[T
 Any"numpy.dtype
 None*\
 selfR
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype0:builtins.property`
-PeriodDtype%pandas.core.dtypes.dtypes.PeriodDtype".pandas.core.dtypes.dtypes.PandasExtensionDtype*
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype0:builtins.property`
+PeriodDtype%pandas.core.dtypes.dtypes.PeriodDtype".pandas.core.dtypes.dtypes.PandasExtensionDtype*
 __init__.pandas.core.dtypes.dtypes.PeriodDtype.__init__"
 None*X
 selfN
-%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype*
-freq
-:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
-builtins.str"builtins.strP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset *
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype*
+freq
+wUnion[builtins.str,pandas._libs.tslibs.offsets.SingleConstructorOffset,pandas._libs.tslibs.offsets.RelativeDeltaOffset]
+builtins.str"builtins.strj
+3pandas._libs.tslibs.offsets.SingleConstructorOffset"3pandas._libs.tslibs.offsets.SingleConstructorOffsetb
+/pandas._libs.tslibs.offsets.RelativeDeltaOffset"/pandas._libs.tslibs.offsets.RelativeDeltaOffset *
 freq*pandas.core.dtypes.dtypes.PeriodDtype.freq"P
 &pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*X
 selfN
@@ -50881,9 +57423,9 @@ aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[T
 na_value.pandas.core.dtypes.dtypes.PeriodDtype.na_value"J
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*X
 selfN
-%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype0:builtins.property`	
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype0:builtins.property`	
 
-DateOffset&pandas._libs.tslibs.offsets.DateOffset"/pandas._libs.tslibs.offsets.RelativeDeltaOffset*
+DateOffset&pandas._libs.tslibs.offsets.DateOffset"/pandas._libs.tslibs.offsets.RelativeDeltaOffset*
 __init__/pandas._libs.tslibs.offsets.DateOffset.__init__"
 None*Z
 selfP
@@ -50917,9 +57459,11 @@ DateOffset&pandas._libs.tslibs.offsets.DateOffset"/pandas._libs.tslibs.offsets.
 month
 builtins.int"builtins.int *'
 day
-builtins.int"builtins.int *+
-weekday
-builtins.int"builtins.int *(
+builtins.int"builtins.int *Q
+weekdayB
+Union[builtins.int,Any]
+builtins.int"builtins.int
+Any *(
 hour
 builtins.int"builtins.int **
 minute
@@ -50974,7 +57518,7 @@ PUnion[builtins.str,numpy.dtype[Any],pandas.core.dtypes.base.ExtensionDtype,None
 &pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
 None **
 copy
-
builtins.bool"
builtins.bool 
+
builtins.bool"
builtins.bool 
 
 date_range(pandas.core.indexes.datetimes.date_range"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
@@ -51032,9 +57576,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *
-unit
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *
+unit
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -51042,7 +57588,7 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
+builtins.str"builtins.str"pandas._typing.TimeUnit
 None 
 
 period_range'pandas.core.indexes.period.period_range"P
@@ -51127,8 +57673,8 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 accuracy
 builtins.int"builtins.int *4
 use_eng_prefix
-
builtins.bool"
builtins.bool "
-	factorize pandas.core.algorithms.factorize
+
builtins.bool"
builtins.bool "
+	factorize pandas.core.algorithms.factorize
 	factorize pandas.core.algorithms.factorize"
 4Tuple[numpy.ndarray[Any,Any],numpy.ndarray[Any,Any]]9
 numpy.ndarray[Any,Any]
@@ -51136,14 +57682,11 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Any"
numpy.ndarray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-values
-3Union[typing.Sequence[Any],numpy.recarray[Any,Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence;
-numpy.recarray[Any,Any]
+Any"
numpy.ndarray*E
+values9
+numpy.ndarray[Any,Any]
 Any
-Any"numpy.recarray**
+Any"
numpy.ndarray**
 sort
 
builtins.bool"
builtins.bool *5
 use_na_sentinel
@@ -51188,7 +57731,7 @@ HTuple[numpy.ndarray[Any,Any],pandas.core.arrays.categorical.Categorical]9
 	size_hintD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None 0:typing.overloadX"
+None 0:typing.overloadX"
 uniquepandas.core.algorithms.unique
 uniquepandas.core.algorithms.unique"P
 &pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*\
@@ -51229,18 +57772,15 @@ DUnion[numpy.ndarray[Any,Any],pandas.core.arrays.base.ExtensionArray]9
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*P
 valuesD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series0:typing.overloadX
+Any"pandas.core.series.Series0:typing.overloadX
 uniquepandas.core.algorithms.unique"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-values
-0Union[numpy.ndarray[Any,Any],builtins.list[Any]]9
+Any"
numpy.ndarray*E
+values9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray,
-builtins.list[Any]
-Any"
builtins.list0:typing.overloadX
+Any"
numpy.ndarray0:typing.overloadX
 uniquepandas.core.algorithms.unique"P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*\
 valuesP
@@ -51780,7 +58320,7 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType 0:typing.overloadX"\
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType 0:typing.overloadX"Z
 to_datetime'pandas.core.tools.datetimes.to_datetime
 to_datetime'pandas.core.tools.datetimes.to_datetime"T
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
@@ -51891,7 +58431,7 @@ eUnion[TypeAlias[Union[builtins.float,builtins.str]],datetime.datetime,numpy.dat
 builtins.float"builtins.float
 builtins.str"builtins.str"(pandas._typing.TimestampConvertibleTypes *+
 cache
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 to_datetime'pandas.core.tools.datetimes.to_datetime"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
 arg
@@ -51902,16 +58442,14 @@ BTypeAlias[Union[TypeAlias[TypedDict],pandas.core.frame.DataFrame]]
 7Union[TypeAlias[TypedDict],pandas.core.frame.DataFrame]H
 TypeAlias[TypedDict]
 	TypedDict"pandas._typing.FulldatetimeDict:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas._typing.DictConvertible*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas._typing.DictConvertible*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *.
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *.
 dayfirst
 
builtins.bool"
builtins.bool */
 	yearfirst
@@ -51948,22 +58486,24 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.float"builtins.float
 builtins.str"builtins.str"(pandas._typing.TimestampConvertibleTypes *+
 cache
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 to_datetime'pandas.core.tools.datetimes.to_datetime"Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-arg
-Union[typing.Sequence[Union[builtins.float,datetime.datetime]],builtins.list[builtins.str],builtins.tuple[Union[builtins.float,builtins.str,datetime.datetime]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.indexes.base.Index[Any],pandas.core.arrays.base.ExtensionArray]
-8typing.Sequence[Union[builtins.float,datetime.datetime]]u
-'Union[builtins.float,datetime.datetime] 
-builtins.float"builtins.float&
-datetime.datetime"datetime.datetime"typing.SequenceJ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+
+arg
+
+Union[typing.Sequence[Union[builtins.float,datetime.date]],builtins.list[builtins.str],builtins.tuple[Union[builtins.float,builtins.str,datetime.date]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.indexes.base.Index[Any],pandas.core.arrays.base.ExtensionArray]
+4typing.Sequence[Union[builtins.float,datetime.date]]i
+#Union[builtins.float,datetime.date] 
+builtins.float"builtins.float
+
datetime.date"
datetime.date"typing.SequenceJ
 builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-Dbuiltins.tuple[Union[builtins.float,builtins.str,datetime.datetime]]
-4Union[builtins.float,builtins.str,datetime.datetime] 
+builtins.str"builtins.str"
builtins.list
+@builtins.tuple[Union[builtins.float,builtins.str,datetime.date]]
+0Union[builtins.float,builtins.str,datetime.date] 
 builtins.float"builtins.float
-builtins.str"builtins.str&
-datetime.datetime"datetime.datetime"builtins.tuple
+builtins.str"builtins.str
+
datetime.date"
datetime.date"builtins.tuple
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
@@ -51972,16 +58512,14 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayN
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.IndexP
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *.
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *.
 dayfirst
 
builtins.bool"
builtins.bool */
 	yearfirst
@@ -52018,7 +58556,7 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.float"builtins.float
 builtins.str"builtins.str"(pandas._typing.TimestampConvertibleTypes *+
 cache
-
builtins.bool"
builtins.bool 0:typing.overloadX"\
+
builtins.bool"
builtins.bool 0:typing.overloadX"5
 
 to_numeric$pandas.core.tools.numeric.to_numeric
 
@@ -52071,72 +58609,7 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX$
-
-to_numeric$pandas.core.tools.numeric.to_numeric"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-arg
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*C
-errors7
-Literal[builtins.str]	
-builtins.str"builtins.str*
-downcast
-nTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]]
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"#pandas.core.tools.numeric._Downcast *
-
dtype_backend
-tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.DtypeBackend
-/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
-$Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
 
 to_numeric$pandas.core.tools.numeric.to_numeric"
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -52153,16 +58626,14 @@ DUnion[builtins.list[Any],builtins.tuple[Any],numpy.ndarray[Any,Any]],
 Any"builtins.tuple9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"
numpy.ndarray*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *
 downcast
 nTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]]
 cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
@@ -52185,23 +58656,21 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
 
 to_numeric$pandas.core.tools.numeric.to_numeric"D
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series*M
 argD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"pandas.core.series.Series*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *
 downcast
 nTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]]
 cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
@@ -52224,39 +58693,19 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX"ϝ
-to_timedelta)pandas.core.tools.timedeltas.to_timedelta1
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX"|
+to_timedelta)pandas.core.tools.timedeltas.to_timedelta&
 to_timedelta)pandas.core.tools.timedeltas.to_timedelta"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
 arg
 5Union[builtins.str,builtins.float,datetime.timedelta]
 builtins.str"builtins.str 
 builtins.float"builtins.float(
-datetime.timedelta"datetime.timedelta*+
-unit+
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+datetime.timedelta"datetime.timedelta*!
+unit!
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -52325,45 +58774,23 @@ $Literal[pandas._libs.lib._NoDefault]	:
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str"3pandas._libs.tslibs.timedeltas.TimeDeltaUnitChoices
-None *
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce 0:typing.overloadX0
+builtins.str"builtins.str"pandas._typing.RaiseCoerce 0:typing.overloadX%
 to_timedelta)pandas.core.tools.timedeltas.to_timedelta"H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*M
 argD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*+
-unit+
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"pandas.core.series.Series*!
+unit!
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -52432,29 +58859,26 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str"3pandas._libs.tslibs.timedeltas.TimeDeltaUnitChoices
-None *
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce 0:typing.overloadX;
+builtins.str"builtins.str"pandas._typing.RaiseCoerce 0:typing.overloadX/
 to_timedelta)pandas.core.tools.timedeltas.to_timedelta"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-arg
-Union[typing.Sequence[Union[builtins.float,datetime.timedelta]],builtins.list[Union[builtins.str,builtins.float,datetime.timedelta]],builtins.tuple[Union[builtins.str,builtins.float,datetime.timedelta]],builtins.range,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.indexes.base.Index[Any]]
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+
+arg
+
+Union[pandas._typing.SequenceNotStr[Any],typing.Sequence[Union[builtins.float,datetime.timedelta]],builtins.tuple[Union[builtins.str,builtins.float,datetime.timedelta]],builtins.range,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.indexes.base.Index[Any]]L
+"pandas._typing.SequenceNotStr[Any]
+Any"pandas._typing.SequenceNotStr
 9typing.Sequence[Union[builtins.float,datetime.timedelta]]x
 (Union[builtins.float,datetime.timedelta] 
 builtins.float"builtins.float(
-datetime.timedelta"datetime.timedelta"typing.Sequence
-Dbuiltins.list[Union[builtins.str,builtins.float,datetime.timedelta]]
-5Union[builtins.str,builtins.float,datetime.timedelta]
-builtins.str"builtins.str 
-builtins.float"builtins.float(
-datetime.timedelta"datetime.timedelta"
builtins.list
+datetime.timedelta"datetime.timedelta"typing.Sequence
 Ebuiltins.tuple[Union[builtins.str,builtins.float,datetime.timedelta]]
 5Union[builtins.str,builtins.float,datetime.timedelta]
 builtins.str"builtins.str 
@@ -52468,31 +58892,11 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 Any
 Any"
numpy.ndarray"pandas._typing.ArrayLikeN
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*+
-unit+
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"pandas.core.indexes.base.Index*!
+unit!
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -52561,16 +58965,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str"3pandas._libs.tslibs.timedeltas.TimeDeltaUnitChoices
-None *
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce 0:typing.overloadX"
+builtins.str"builtins.str"pandas._typing.RaiseCoerce 0:typing.overloadX"
 isnapandas.core.dtypes.missing.isna
 isnapandas.core.dtypes.missing.isna":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
@@ -52600,9 +59002,9 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
-isnapandas.core.dtypes.missing.isna"
-
builtins.bool"
builtins.bool*
+Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
+isnapandas.core.dtypes.missing.isna"
+Any*
 obj
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.tslibs.nattype.NaTType,pandas._libs.missing.NAType,None]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -52625,7 +59027,7 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.complex"builtins.complex"pandas._typing.ScalarJ
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType:
 pandas._libs.missing.NAType"pandas._libs.missing.NAType
-None0:typing.overloadX"
+None0:typing.overloadX"
 notna pandas.core.dtypes.missing.notna
 notna pandas.core.dtypes.missing.notna":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
@@ -52655,9 +59057,9 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
-notna pandas.core.dtypes.missing.notna"
-
builtins.bool"
builtins.bool*
+Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
+notna pandas.core.dtypes.missing.notna"
+Any*
 obj
 bUnion[pandas._typing.ScalarT,pandas._libs.tslibs.nattype.NaTType,pandas._libs.missing.NAType,None]
 pandas._typing.ScalarT
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arraylike.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arraylike.protobuf
index 807ad85b11..69828bfa26 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arraylike.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arraylike.protobuf
@@ -1,5 +1,5 @@
 
-pandas.core.arraylikeN
+pandas.core.arraylikeF
 OpsMixinpandas.core.arraylike.OpsMixin"builtins.object*
 __eq__%pandas.core.arraylike.OpsMixin.__eq__"
 #pandas.core.arraylike.OpsMixin.Self@
@@ -108,24 +108,6 @@
 pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin(*
 #pandas.core.arraylike.OpsMixin.Self@
 pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin(*	
-Any*
-__truediv__*pandas.core.arraylike.OpsMixin.__truediv__"
-#pandas.core.arraylike.OpsMixin.Self@
-pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin(*
-#pandas.core.arraylike.OpsMixin.Self@
-pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin(*	
-Any*
-__rtruediv__+pandas.core.arraylike.OpsMixin.__rtruediv__"
-#pandas.core.arraylike.OpsMixin.Self@
-pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin(*
-#pandas.core.arraylike.OpsMixin.Self@
-pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin(*	
-Any*
-
__rfloordiv__,pandas.core.arraylike.OpsMixin.__rfloordiv__"
-#pandas.core.arraylike.OpsMixin.Self@
-pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin(*
-#pandas.core.arraylike.OpsMixin.Self@
-pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin"pandas.core.arraylike.OpsMixin(*	
 Any*
 __mod__&pandas.core.arraylike.OpsMixin.__mod__"
 #pandas.core.arraylike.OpsMixin.Self@
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.base.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.base.protobuf
index 1a07434401..f3b8be562f 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.base.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.base.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.boolean.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.boolean.protobuf
index db5d3d47d4..e8bb140f56 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.boolean.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.boolean.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.categorical.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.categorical.protobuf
index c0060dc1fb..e93a1fb2f5 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.categorical.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.categorical.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.datetimelike.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.datetimelike.protobuf
index e826cf7b75..f4ddae3ee8 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.datetimelike.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.datetimelike.protobuf
@@ -1,6 +1,10 @@
 
-pandas.core.arrays.datetimelike^
+pandas.core.arrays.datetimelikek
 NaTType#pandas._libs.tslibs.nattype.NaTType"builtins.object*
+__hash__,pandas._libs.tslibs.nattype.NaTType.__hash__"
+builtins.int"builtins.int*T
+selfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*
 asm8(pandas._libs.tslibs.nattype.NaTType.asm8"$
 numpy.datetime64"numpy.datetime64*T
 selfJ
@@ -260,7 +264,39 @@ nanosecond.pandas._libs.tslibs.nattype.NaTType.nanosecond"
 __ne__*pandas._libs.tslibs.nattype.NaTType.__ne__"
 
builtins.bool"
builtins.bool*LJ
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*$"
-builtins.object"builtins.objectr
+builtins.object"builtins.object*
+unit(pandas._libs.tslibs.nattype.NaTType.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*T
+selfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:builtins.property`*
+as_unit+pandas._libs.tslibs.nattype.NaTType.as_unit"
+(pandas._libs.tslibs.nattype.NaTType.SelfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType(*
+self
+(pandas._libs.tslibs.nattype.NaTType.SelfJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool r
 value)pandas._libs.tslibs.nattype.NaTType.value
 4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
 )numpy.signedinteger[numpy._typing._64Bit],
@@ -276,8 +312,38 @@ nanosecond.pandas._libs.tslibs.nattype.NaTType.nanosecond"
 DatelikeOps+pandas.core.arrays.datetimelike.DatelikeOps"builtins.object*[
 strftime4pandas.core.arrays.datetimelike.DatelikeOps.strftime*
 self*
-date_format
-TimelikeOps+pandas.core.arrays.datetimelike.TimelikeOps"builtins.object*
+date_format
+TimelikeOps+pandas.core.arrays.datetimelike.TimelikeOps"builtins.object*
+unit0pandas.core.arrays.datetimelike.TimelikeOps.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*d
+selfZ
++pandas.core.arrays.datetimelike.TimelikeOps"+pandas.core.arrays.datetimelike.TimelikeOps0:builtins.property`*
+as_unit3pandas.core.arrays.datetimelike.TimelikeOps.as_unit"
+0pandas.core.arrays.datetimelike.TimelikeOps.SelfZ
++pandas.core.arrays.datetimelike.TimelikeOps"+pandas.core.arrays.datetimelike.TimelikeOps"+pandas.core.arrays.datetimelike.TimelikeOps(*
+self
+0pandas.core.arrays.datetimelike.TimelikeOps.SelfZ
++pandas.core.arrays.datetimelike.TimelikeOps"+pandas.core.arrays.datetimelike.TimelikeOps"+pandas.core.arrays.datetimelike.TimelikeOps(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*
 round1pandas.core.arrays.datetimelike.TimelikeOps.round"
 Any*d
 selfZ
@@ -307,7 +373,7 @@ nanosecond.pandas._libs.tslibs.nattype.NaTType.nanosecond"
 	ambiguous
 builtins.str"builtins.str */
 nonexistent
-builtins.str"builtins.str J
+builtins.str"builtins.str =
 DatetimeLikeArrayMixin6pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin")pandas.core.arrays.base.ExtensionOpsMixin"&pandas.core.arrays.base.ExtensionArray*
 ndim;pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin.ndim"
 builtins.int"builtins.int*z
@@ -373,33 +439,7 @@ _Union[builtins.int,typing.Sequence[builtins.int],typing.Sequence[builtins.bool]
 self*
 dtype *Q
 unique=pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin.unique*
-self*
-take;pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin.take"
-;pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin.Selfp
-6pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin"6pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin"6pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin(*
-self
-;pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin.Selfp
-6pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin"6pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin"6pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin(*
-indices
-TypeAlias[Union[typing.Sequence[builtins.int],typing.Sequence[numpy.integer[Any]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
-Union[typing.Sequence[builtins.int],typing.Sequence[numpy.integer[Any]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]N
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequenced
-#typing.Sequence[numpy.integer[Any]],
-numpy.integer[Any]
-Any"
numpy.integer"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.TakeIndexer*0
-
-allow_fill
-
builtins.bool"
builtins.bool *
-
-fill_value
-Any *M
+self*M
 copy;pandas.core.arrays.datetimelike.DatetimeLikeArrayMixin.copy*
 self*
 shift
-dtype+pandas.core.arrays.period.PeriodArray.dtype*
-self*
+
builtins.bool"
builtins.bool *
+dtype+pandas.core.arrays.period.PeriodArray.dtype"N
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype*X
+selfN
+%pandas.core.arrays.period.PeriodArray"%pandas.core.arrays.period.PeriodArray0:builtins.property`*
 	__array__/pandas.core.arrays.period.PeriodArray.__array__"9
 numpy.ndarray[Any,Any]
 Any
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.protobuf
index 5ef1b3f7f4..c221434aa2 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.sparse.array.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.sparse.array.protobuf
index d8c8618fb0..783ef1dfe1 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.sparse.array.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.sparse.array.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.sparse.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.sparse.protobuf
index 9e89fb20a9..b24294529e 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.sparse.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.arrays.sparse.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.base.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.base.protobuf
index f6c13820f6..fac51b4122 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.base.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.base.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.computation.pytables.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.computation.pytables.protobuf
index 4efab032b7..c17aab07c6 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.computation.pytables.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.computation.pytables.protobuf
@@ -284,13 +284,11 @@ queryables1pandas.core.computation.pytables.BinOp.queryablesW
 encoding/pandas.core.computation.pytables.BinOp.encoding&
 builtins.ellipsis"builtins.ellipsisre
 	condition0pandas.core.computation.pytables.BinOp.condition&
-builtins.ellipsis"builtins.ellipsis
+builtins.ellipsis"builtins.ellipsis
 FilterBinOp,pandas.core.computation.pytables.FilterBinOp"&pandas.core.computation.pytables.BinOp*G
 invert3pandas.core.computation.pytables.FilterBinOp.invert*
 self*G
 format3pandas.core.computation.pytables.FilterBinOp.format*
-self*K
-evaluate5pandas.core.computation.pytables.FilterBinOp.evaluate*
 self*
 generate_filter_op?pandas.core.computation.pytables.FilterBinOp.generate_filter_op"
 Any*f
@@ -305,28 +303,22 @@ queryables1pandas.core.computation.pytables.BinOp.queryablesW
 AnyN
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.Index
-None
+None
 JointFilterBinOp1pandas.core.computation.pytables.JointFilterBinOp",pandas.core.computation.pytables.FilterBinOp*
 format8pandas.core.computation.pytables.JointFilterBinOp.format"
 None*p
 selff
-1pandas.core.computation.pytables.JointFilterBinOp"1pandas.core.computation.pytables.JointFilterBinOp*P
-evaluate:pandas.core.computation.pytables.JointFilterBinOp.evaluate*
-self
+1pandas.core.computation.pytables.JointFilterBinOp"1pandas.core.computation.pytables.JointFilterBinOp
 ConditionBinOp/pandas.core.computation.pytables.ConditionBinOp"&pandas.core.computation.pytables.BinOp*
 invert6pandas.core.computation.pytables.ConditionBinOp.invert"
 None*l
 selfb
 /pandas.core.computation.pytables.ConditionBinOp"/pandas.core.computation.pytables.ConditionBinOp*J
 format6pandas.core.computation.pytables.ConditionBinOp.format*
-self*N
-evaluate8pandas.core.computation.pytables.ConditionBinOp.evaluate*
 selfrn
 	condition9pandas.core.computation.pytables.ConditionBinOp.condition&
-builtins.ellipsis"builtins.ellipsis
-JointConditionBinOp4pandas.core.computation.pytables.JointConditionBinOp"/pandas.core.computation.pytables.ConditionBinOp*S
-evaluate=pandas.core.computation.pytables.JointConditionBinOp.evaluate*
-selfrs
+builtins.ellipsis"builtins.ellipsis
+JointConditionBinOp4pandas.core.computation.pytables.JointConditionBinOp"/pandas.core.computation.pytables.ConditionBinOprs
 	condition>pandas.core.computation.pytables.JointConditionBinOp.condition&
 builtins.ellipsis"builtins.ellipsis
 UnaryOp(pandas.core.computation.pytables.UnaryOp"#pandas.core.computation.ops.UnaryOp*L
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.api.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.api.protobuf
index 62b3783593..7b1269b9f2 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.api.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.api.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.base.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.base.protobuf
index d0fe6d468e..0206d1454f 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.base.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.base.protobuf
@@ -1,12 +1,14 @@
 
-pandas.core.dtypes.base
+pandas.core.dtypes.base
 ExtensionDtype&pandas.core.dtypes.base.ExtensionDtype"builtins.object*
 na_value/pandas.core.dtypes.base.ExtensionDtype.na_value""
 builtins.object"builtins.object*Z
 selfP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype0:builtins.property`*
-kind+pandas.core.dtypes.base.ExtensionDtype.kind"
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype0:builtins.property`*
+kind+pandas.core.dtypes.base.ExtensionDtype.kind"
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.common.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.common.protobuf
index 09f51cfa98..ef10b39281 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.common.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.common.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.dtypes.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.dtypes.protobuf
index c077108f9b..cdb782e71d 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.dtypes.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.dtypes.protobuf
@@ -1,12 +1,14 @@
 
-pandas.core.dtypes.dtypes
+pandas.core.dtypes.dtypes
 ExtensionDtype&pandas.core.dtypes.base.ExtensionDtype"builtins.object*
 na_value/pandas.core.dtypes.base.ExtensionDtype.na_value""
 builtins.object"builtins.object*Z
 selfP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype0:builtins.property`*
-kind+pandas.core.dtypes.base.ExtensionDtype.kind"
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype0:builtins.property`*
+kind+pandas.core.dtypes.base.ExtensionDtype.kind"
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -133,16 +135,17 @@ $TypeAlias[Union[builtins.bool,None]]G
 na_value2pandas.core.dtypes.dtypes.DatetimeTZDtype.na_value"J
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*`
 selfV
-)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype0:builtins.property`
-PeriodDtype%pandas.core.dtypes.dtypes.PeriodDtype".pandas.core.dtypes.dtypes.PandasExtensionDtype*
+)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype0:builtins.property`
+PeriodDtype%pandas.core.dtypes.dtypes.PeriodDtype".pandas.core.dtypes.dtypes.PandasExtensionDtype*
 __init__.pandas.core.dtypes.dtypes.PeriodDtype.__init__"
 None*X
 selfN
-%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype*
-freq
-:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
-builtins.str"builtins.strP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset *
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype*
+freq
+wUnion[builtins.str,pandas._libs.tslibs.offsets.SingleConstructorOffset,pandas._libs.tslibs.offsets.RelativeDeltaOffset]
+builtins.str"builtins.strj
+3pandas._libs.tslibs.offsets.SingleConstructorOffset"3pandas._libs.tslibs.offsets.SingleConstructorOffsetb
+/pandas._libs.tslibs.offsets.RelativeDeltaOffset"/pandas._libs.tslibs.offsets.RelativeDeltaOffset *
 freq*pandas.core.dtypes.dtypes.PeriodDtype.freq"P
 &pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*X
 selfN
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.generic.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.generic.protobuf
deleted file mode 100644
index dda9fa5a1e..0000000000
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.generic.protobuf
+++ /dev/null
@@ -1,6 +0,0 @@
-
-pandas.core.dtypes.generic*
-__annotations__*pandas.core.dtypes.generic.__annotations__W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.inference.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.inference.protobuf
index fe7b599a8f..56c33a92f2 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.inference.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.inference.protobuf
@@ -52,9 +52,6 @@ is_complex'pandas.core.dtypes.inference.is_complexK
 builtins.function"builtins.function*
 	is_scalar&pandas.core.dtypes.inference.is_scalarK
 CallableType[builtins.function]&
-builtins.function"builtins.function*
-is_interval(pandas.core.dtypes.inference.is_intervalK
-CallableType[builtins.function]&
 builtins.function"builtins.function*
 is_list_like)pandas.core.dtypes.inference.is_list_likeK
 CallableType[builtins.function]&
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.missing.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.missing.protobuf
index 9472459cb5..71641f89a3 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.missing.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.dtypes.missing.protobuf
@@ -1,5 +1,5 @@
 
-pandas.core.dtypes.missing"
+pandas.core.dtypes.missing"
 isnapandas.core.dtypes.missing.isna
 isnapandas.core.dtypes.missing.isna":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
@@ -29,9 +29,9 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
-isnapandas.core.dtypes.missing.isna"
-
builtins.bool"
builtins.bool*
+Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
+isnapandas.core.dtypes.missing.isna"
+Any*
 obj
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.tslibs.nattype.NaTType,pandas._libs.missing.NAType,None]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -54,7 +54,7 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.complex"builtins.complex"pandas._typing.ScalarJ
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType:
 pandas._libs.missing.NAType"pandas._libs.missing.NAType
-None0:typing.overloadX"
+None0:typing.overloadX"
 notna pandas.core.dtypes.missing.notna
 notna pandas.core.dtypes.missing.notna":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
@@ -84,9 +84,9 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
-notna pandas.core.dtypes.missing.notna"
-
builtins.bool"
builtins.bool*
+Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
+notna pandas.core.dtypes.missing.notna"
+Any*
 obj
 bUnion[pandas._typing.ScalarT,pandas._libs.tslibs.nattype.NaTType,pandas._libs.missing.NAType,None]
 pandas._typing.ScalarT
@@ -115,7 +115,9 @@ bUnion[pandas._typing.ScalarT,pandas._libs.tslibs.nattype.NaTType,pandas._libs.m
 builtins.str"builtins.str
 Any"
builtins.dict*
 npnumpy *
-nptnumpy.typing *e
+nptnumpy.typing *4
+TypeIs!pandas.core.dtypes.missing.TypeIs
+Any*e
 isposinf_scalar*pandas.core.dtypes.missing.isposinf_scalar&
 builtins.ellipsis"builtins.ellipsis*e
 isneginf_scalar*pandas.core.dtypes.missing.isneginf_scalar&
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.frame.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.frame.protobuf
index 5728619cc4..318d82ffde 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.frame.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.frame.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.generic.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.generic.protobuf
index 87332a4998..613b26f51e 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.generic.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.generic.protobuf
@@ -1,12 +1,12 @@
 
-pandas.core.generic
-NDFramepandas.core.generic.NDFrame""pandas.core.indexing.IndexingMixin*
-	set_flags%pandas.core.generic.NDFrame.set_flags"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*~
-selft
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame**
+pandas.core.generic
+NDFramepandas.core.generic.NDFrame""pandas.core.indexing.IndexingMixin*
+	set_flags%pandas.core.generic.NDFrame.set_flags"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(**
 copy
 
builtins.bool"
builtins.bool *f
 allows_duplicate_labelsG
@@ -31,31 +31,13 @@
 size pandas.core.generic.NDFrame.size"
 builtins.int"builtins.int*D
 self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame0:builtins.property`*
-swapaxes$pandas.core.generic.NDFrame.swapaxes":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-axis1
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex*
-axis2
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex**
-copy
-
builtins.bool"
builtins.bool *
-	droplevel%pandas.core.generic.NDFrame.droplevel":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame0:builtins.property`*
+	droplevel%pandas.core.generic.NDFrame.droplevel"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 level
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
@@ -71,15 +53,15 @@
 squeeze#pandas.core.generic.NDFrame.squeeze*
 self*
 
-axis *
+axis *
 equals"pandas.core.generic.NDFrame.equals"
 
builtins.bool"
builtins.bool*D
 self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+other
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -106,24 +88,21 @@
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-__neg__#pandas.core.generic.NDFrame.__neg__"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*vt
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-__pos__#pandas.core.generic.NDFrame.__pos__"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*vt
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+__neg__#pandas.core.generic.NDFrame.__neg__"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+__pos__#pandas.core.generic.NDFrame.__pos__"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 __nonzero__'pandas.core.generic.NDFrame.__nonzero__"
 None*D
 self:
@@ -131,14 +110,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 bool pandas.core.generic.NDFrame.bool"
 
builtins.bool"
builtins.bool*D
 self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame0:typing.finalP*
-__abs__#pandas.core.generic.NDFrame.__abs__":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*<:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-	__round__%pandas.core.generic.NDFrame.__round__":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*,
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame0:typing.finalP*
+__abs__#pandas.core.generic.NDFrame.__abs__"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+	__round__%pandas.core.generic.NDFrame.__round__"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*,
 decimals
 builtins.int"builtins.int *2
 keys pandas.core.generic.NDFrame.keys*
@@ -226,9 +209,9 @@ sheet_name
 os.PathLike[builtins.str]
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePath:
 pandas.io.pytables.HDFStore"pandas.io.pytables.HDFStore*%
-key
+key
 builtins.str"builtins.str*
-mode
+mode
 HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -236,11 +219,11 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str *U
-	complevelD
+	complevelD
 Union[builtins.int,None]
 builtins.int"builtins.int
 None *
-complib
+complib
 uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
 ^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
@@ -253,9 +236,9 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str"pandas._typing.HDFCompLib
 None *,
-append
+append
 
builtins.bool"
builtins.bool *
-format
+format
 cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -266,9 +249,9 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str
 None *+
-index
+index
 
builtins.bool"
builtins.bool *
-min_itemsize
+min_itemsize
 NUnion[builtins.int,builtins.dict[pandas._typing.HashableT1,builtins.int],None]
 builtins.int"builtins.int
 5builtins.dict[pandas._typing.HashableT1,builtins.int]R
@@ -276,15 +259,15 @@ NUnion[builtins.int,builtins.dict[pandas._typing.HashableT1,builtins.int],None]
 typing.Hashable"typing.Hashable"typing.Hashable
 builtins.int"builtins.int"
builtins.dict
 None *S
-nan_repD
+nan_repD
 Union[builtins.str,None]
 builtins.str"builtins.str
 None *U
-dropnaG
+dropnaG
 Union[builtins.bool,None]
 
builtins.bool"
builtins.bool
 None *
-data_columns
+data_columns
 KUnion[Literal[builtins.bool],builtins.list[pandas._typing.HashableT2],None]:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
@@ -292,7 +275,7 @@ KUnion[Literal[builtins.bool],builtins.list[pandas._typing.HashableT2],None]:
 pandas._typing.HashableT2"
 typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
 None *
-errors
+errors
 Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -308,7 +291,7 @@ KUnion[Literal[builtins.bool],builtins.list[pandas._typing.HashableT2],None]:
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str *,
-encoding
+encoding
 builtins.str"builtins.str *
 to_sql"pandas.core.generic.NDFrame.to_sql"D
 Union[builtins.int,None]
@@ -430,69 +413,29 @@ jUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 builtins.str"builtins.str
 None *
 kwargs
-Any*
-take pandas.core.generic.NDFrame.take":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+Any*
+take pandas.core.generic.NDFrame.take"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 indices
 Any*
 axis
-Any *V
-is_copyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
+Any *
 kwargs
 Any*
 __delitem__'pandas.core.generic.NDFrame.__delitem__"
 None*<:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*$"
-typing.Hashable"typing.Hashable*
-getpandas.core.generic.NDFrame.get"	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*+
-key"
-builtins.object"builtins.object*
-default
-Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],None]	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype
-None *
-reindex_like(pandas.core.generic.NDFrame.reindex_like":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+typing.Hashable"typing.Hashable*
+reindex_like(pandas.core.generic.NDFrame.reindex_like"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 other
 Any*R
 methodD
@@ -504,19 +447,23 @@ jUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 limit
 Any *
 	tolerance
-Any *
+Any *
 
-add_prefix&pandas.core.generic.NDFrame.add_prefix":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*(
+add_prefix&pandas.core.generic.NDFrame.add_prefix"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*(
 prefix
-builtins.str"builtins.str*
+builtins.str"builtins.str*
 
-add_suffix&pandas.core.generic.NDFrame.add_suffix":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*(
+add_suffix&pandas.core.generic.NDFrame.add_suffix"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*(
 suffix
 builtins.str"builtins.str*
 
@@ -565,11 +512,13 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 sort_remaining
 
builtins.bool"
builtins.bool *2
 ignore_index
-
builtins.bool"
builtins.bool *
-filter"pandas.core.generic.NDFrame.filter":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+
builtins.bool"
builtins.bool *
+filter"pandas.core.generic.NDFrame.filter"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 items
 Any *P
 likeD
@@ -581,44 +530,29 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.str"builtins.str
 None *
 axis
-Any *
-head pandas.core.generic.NDFrame.head"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*~
-selft
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*%
+Any *
+head pandas.core.generic.NDFrame.head"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*%
 n
-builtins.int"builtins.int *
-tail pandas.core.generic.NDFrame.tail"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*~
-selft
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*%
+builtins.int"builtins.int *
+tail pandas.core.generic.NDFrame.tail"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*%
 n
-builtins.int"builtins.int *
-pipe pandas.core.generic.NDFrame.pipe"I
-pandas._typing.T"
-builtins.object"builtins.object"builtins.object*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-func
-ZUnion[CallableType[builtins.function],Tuple[CallableType[builtins.function],builtins.str]]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-3Tuple[CallableType[builtins.function],builtins.str]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str*
-args
-Any*
-kwargs
-Any*
-__finalize__(pandas.core.generic.NDFrame.__finalize__":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+builtins.int"builtins.int *
+__finalize__(pandas.core.generic.NDFrame.__finalize__"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 other
 Any*
 method
@@ -643,37 +577,43 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 self:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame0:builtins.property`*M
 dtypes"pandas.core.generic.NDFrame.dtypes*
-self0:builtins.property`*
-copy pandas.core.generic.NDFrame.copy"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*~
-selft
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame**
+self0:builtins.property`*
+copy pandas.core.generic.NDFrame.copy"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(**
 deep
-
builtins.bool"
builtins.bool *
-__copy__$pandas.core.generic.NDFrame.__copy__":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame**
+
builtins.bool"
builtins.bool *
+__copy__$pandas.core.generic.NDFrame.__copy__"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(**
 deep
-
builtins.bool"
builtins.bool *
-__deepcopy__(pandas.core.generic.NDFrame.__deepcopy__":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+
builtins.bool"
builtins.bool *
+__deepcopy__(pandas.core.generic.NDFrame.__deepcopy__"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 memo
-Any *
-
infer_objects)pandas.core.generic.NDFrame.infer_objects":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-convert_dtypes*pandas.core.generic.NDFrame.convert_dtypes"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*~
-selft
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*3
+Any *
+
infer_objects)pandas.core.generic.NDFrame.infer_objects"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+convert_dtypes*pandas.core.generic.NDFrame.convert_dtypes"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*3
 
infer_objects
 
builtins.bool"
builtins.bool *4
 convert_string
@@ -681,6 +621,8 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 convert_integer
 
builtins.bool"
builtins.bool *5
 convert_boolean
+
builtins.bool"
builtins.bool *6
+convert_floating
 
builtins.bool"
builtins.bool *
 
dtype_backend
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
@@ -688,7 +630,7 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.DtypeBackend *
+builtins.str"builtins.str"pandas._typing.DtypeBackend *
 fillna"pandas.core.generic.NDFrame.fillna"q
 'Union[pandas.core.generic.NDFrame,None]:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame
@@ -696,8 +638,6 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 self:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
 value
-Any *
-method
 Any *
 axis
 Any *-
@@ -750,11 +690,13 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 notnull#pandas.core.generic.NDFrame.notnull":
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
 self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-clip pandas.core.generic.NDFrame.clip":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+clip pandas.core.generic.NDFrame.clip"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 lower
 Any *
 upper
@@ -764,11 +706,13 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 inplace
 
builtins.bool"
builtins.bool *
 kwargs
-Any*
-asfreq"pandas.core.generic.NDFrame.asfreq":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+Any*	
+asfreq"pandas.core.generic.NDFrame.asfreq"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 freq
 Any*
 method
@@ -795,38 +739,168 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 
builtins.bool"
builtins.bool *
 
 fill_value
-Any *
-at_time#pandas.core.generic.NDFrame.at_time":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+Any *
+at_time#pandas.core.generic.NDFrame.at_time"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 time
 Any**
 asof
 
builtins.bool"
builtins.bool *
 axis
-Any *
-between_time(pandas.core.generic.NDFrame.between_time":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+Any *
+between_time(pandas.core.generic.NDFrame.between_time"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 
 start_time
 Any*
 end_time
 Any*
 axis
-Any *
-first!pandas.core.generic.NDFrame.first":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+Any *5
+resample$pandas.core.generic.NDFrame.resample"
+Mpandas.core.resample.DatetimeIndexResampler[pandas.core.generic.NDFrame.Self]
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame("+pandas.core.resample.DatetimeIndexResampler*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+rule
+_Union[TypeAlias[Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]],datetime.timedelta]
+ETypeAlias[Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]]
+:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.strP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas._typing.Frequency(
+datetime.timedelta"datetime.timedelta*	
+axis	
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+closed
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+label
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+
+convention
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str""pandas._typing.TimestampConvention *
+kind
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+on
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+origin
+Union[TypeAlias[Union[pandas._libs.tslibs.timestamps.Timestamp,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,datetime.date,numpy.datetime64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]]]
+TypeAlias[Union[pandas._libs.tslibs.timestamps.Timestamp,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas._libs.tslibs.timestamps.Timestamp,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimeGrouperOrigin
+TypeAlias[Union[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,datetime.date,numpy.datetime64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]]
+Union[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,datetime.date,numpy.datetime64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date$
+numpy.datetime64"numpy.datetime64
+4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
+)numpy.signedinteger[numpy._typing._64Bit],
+numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64 
+builtins.float"builtins.float
+builtins.str"builtins.str"(pandas._typing.TimestampConvertibleTypes *
+offset
+Union[TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]],None]
+TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]]
+Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
+datetime.timedelta"datetime.timedelta&
+numpy.timedelta64"numpy.timedelta64
+4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
+)numpy.signedinteger[numpy._typing._64Bit],
+numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64 
+builtins.float"builtins.float
+builtins.str"builtins.str"(pandas._typing.TimedeltaConvertibleTypes
+None *0
+
+group_keys
+
builtins.bool"
builtins.bool 0:typing.finalP*
+first!pandas.core.generic.NDFrame.first"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 offset
-Any*
-last pandas.core.generic.NDFrame.last":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+Any*
+last pandas.core.generic.NDFrame.last"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 offset
 Any*
 rank pandas.core.generic.NDFrame.rank":
@@ -860,7 +934,7 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 	ascending
 
builtins.bool"
builtins.bool *)
 pct
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 where!pandas.core.generic.NDFrame.where"
 Any*D
 self:
@@ -874,9 +948,7 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 axis
 Any *
 level
-Any *.
-try_cast
-
builtins.bool"
builtins.bool *
+Any *
 mask pandas.core.generic.NDFrame.mask"
 Any*D
 self:
@@ -890,13 +962,13 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 axis
 Any *
 level
-Any *.
-try_cast
-
builtins.bool"
builtins.bool *
-shift!pandas.core.generic.NDFrame.shift":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+Any *
+shift!pandas.core.generic.NDFrame.shift"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 periods
 Any *
 freq
@@ -905,29 +977,13 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Any *
 
 fill_value
-Any *
-slice_shift'pandas.core.generic.NDFrame.slice_shift":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*+
-periods
-builtins.int"builtins.int *
-axis
-Any *
-tshift"pandas.core.generic.NDFrame.tshift":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*+
-periods
-builtins.int"builtins.int *
-freq
-Any *
-axis
-Any *
-truncate$pandas.core.generic.NDFrame.truncate":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+Any *
+truncate$pandas.core.generic.NDFrame.truncate"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 before
 Any *
 after
@@ -935,12 +991,14 @@ fill_value
 axis
 Any **
 copy
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 
-tz_convert&pandas.core.generic.NDFrame.tz_convert":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+tz_convert&pandas.core.generic.NDFrame.tz_convert"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 tz
 Any*
 axis
@@ -948,11 +1006,13 @@ tz_convert&pandas.core.generic.NDFrame.tz_convert":
 level
 Any **
 copy
-
builtins.bool"
builtins.bool *
-tz_localize'pandas.core.generic.NDFrame.tz_localize":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+
builtins.bool"
builtins.bool *
+tz_localize'pandas.core.generic.NDFrame.tz_localize"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 tz
 Any*
 axis
@@ -964,11 +1024,13 @@ tz_convert&pandas.core.generic.NDFrame.tz_convert":
 	ambiguous
 Any */
 nonexistent
-builtins.str"builtins.str *
-abspandas.core.generic.NDFrame.abs":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+builtins.str"builtins.str *
+abspandas.core.generic.NDFrame.abs"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 describe$pandas.core.generic.NDFrame.describe":
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
 self:
@@ -978,16 +1040,14 @@ tz_convert&pandas.core.generic.NDFrame.tz_convert":
 include
 Any *
 exclude
-Any *b
-datetime_is_numericG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
+Any *
 
-pct_change&pandas.core.generic.NDFrame.pct_change":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+pct_change&pandas.core.generic.NDFrame.pct_change"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
 periods
 Any *
 fill_method
@@ -1126,8 +1186,8 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Any"
builtins.dict
 None"pandas._typing.StorageOptions *
 kwargs
-Any0:typing.overloadX2"
-to_latex$pandas.core.generic.NDFrame.to_latex
+Any0:typing.overloadX2!
+to_latex$pandas.core.generic.NDFrame.to_latex
 to_latex$pandas.core.generic.NDFrame.to_latex"
 None*D
 self:
@@ -1145,10 +1205,6 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 'Union[builtins.list[builtins.str],None]J
 builtins.list[builtins.str]
 builtins.str"builtins.str"
builtins.list
-None *U
-	col_spaceD
-Union[builtins.int,None]
-builtins.int"builtins.int
 None *
 header
 0Union[builtins.bool,builtins.list[builtins.str]]
@@ -1216,7 +1272,7 @@ formatters
 positionD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None 0:typing.overloadX
+None 0:typing.overloadX
 to_latex$pandas.core.generic.NDFrame.to_latex"
 builtins.str"builtins.str*D
 self:
@@ -1227,10 +1283,6 @@ formatters
 'Union[builtins.list[builtins.str],None]J
 builtins.list[builtins.str]
 builtins.str"builtins.str"
builtins.list
-None *U
-	col_spaceD
-Union[builtins.int,None]
-builtins.int"builtins.int
 None *
 header
 0Union[builtins.bool,builtins.list[builtins.str]]
@@ -1298,8 +1350,8 @@ formatters
 positionD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None 0:typing.overloadX2S
-to_csv"pandas.core.generic.NDFrame.to_csv+
+None 0:typing.overloadX2V
+to_csv"pandas.core.generic.NDFrame.to_csv-
 to_csv"pandas.core.generic.NDFrame.to_csv"
 None*D
 self:
@@ -1401,8 +1453,9 @@ XUnion[Literal[builtins.bool],builtins.str,builtins.list[pandas._typing.Hashable
 *TypeAlias[builtins.dict[builtins.str,Any]]W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *
-quoting
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -1412,7 +1465,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *-
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *-
 	quotechar
 builtins.str"builtins.str *Z
 lineterminatorD
@@ -1444,7 +1497,7 @@ escapecharD
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
 Any"
builtins.dict
-None"pandas._typing.StorageOptions 0:typing.overloadX'
+None"pandas._typing.StorageOptions 0:typing.overloadX(
 to_csv"pandas.core.generic.NDFrame.to_csv"
 builtins.str"builtins.str*D
 self:
@@ -1537,8 +1590,9 @@ XUnion[Literal[builtins.bool],builtins.str,builtins.list[pandas._typing.Hashable
 *TypeAlias[builtins.dict[builtins.str,Any]]W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *
-quoting
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -1548,7 +1602,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *-
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *-
 	quotechar
 builtins.str"builtins.str *Z
 lineterminatorD
@@ -1580,17 +1634,66 @@ escapecharD
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
 Any"
builtins.dict
-None"pandas._typing.StorageOptions 0:typing.overloadX25
-drop pandas.core.generic.NDFrame.drop
+None"pandas._typing.StorageOptions 0:typing.overloadX2
+drop pandas.core.generic.NDFrame.drop
 drop pandas.core.generic.NDFrame.drop"
 None*D
 self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-labels
-7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+labels
+None *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+index
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
 typing.Hashable"typing.HashableW
  typing.Sequence[typing.Hashable]"
-typing.Hashable"typing.Hashable"typing.Sequence *
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index *
+columns
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+drop pandas.core.generic.NDFrame.drop"
+None*D
+self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+labels
+None *
 axis
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
@@ -1605,17 +1708,21 @@ escapecharD
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+index
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
 typing.Hashable"typing.HashableW
  typing.Sequence[typing.Hashable]"
-typing.Hashable"typing.Hashable"typing.Sequence *
-columns
-7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+columns
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
 typing.Hashable"typing.HashableW
  typing.Sequence[typing.Hashable]"
-typing.Hashable"typing.Hashable"typing.Sequence *
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index *
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -1632,16 +1739,18 @@ escapecharD
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
-drop pandas.core.generic.NDFrame.drop":
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*D
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+drop pandas.core.generic.NDFrame.drop"
+None*D
 self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-labels
-7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+labels
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
 typing.Hashable"typing.HashableW
  typing.Sequence[typing.Hashable]"
-typing.Hashable"typing.Hashable"typing.Sequence *
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
 axis
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
@@ -1656,17 +1765,65 @@ escapecharD
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+index
+None *
+columns
+None *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+drop pandas.core.generic.NDFrame.drop"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+labels
+None *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+index
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
 typing.Hashable"typing.HashableW
  typing.Sequence[typing.Hashable]"
-typing.Hashable"typing.Hashable"typing.Sequence *
-columns
-7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index *
+columns
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
 typing.Hashable"typing.HashableW
  typing.Sequence[typing.Hashable]"
-typing.Hashable"typing.Hashable"typing.Sequence *
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -1683,18 +1840,74 @@ escapecharD
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
-drop pandas.core.generic.NDFrame.drop"q
-'Union[pandas.core.generic.NDFrame,None]:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame
-None*D
-self:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-labels
-7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+drop pandas.core.generic.NDFrame.drop"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+labels
+None *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+index
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+columns
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+drop pandas.core.generic.NDFrame.drop"
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+labels
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
 typing.Hashable"typing.HashableW
  typing.Sequence[typing.Hashable]"
-typing.Hashable"typing.Hashable"typing.Sequence *
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
 axis
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
@@ -1709,17 +1922,172 @@ escapecharD
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+index
+None *
+columns
+None *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+drop pandas.core.generic.NDFrame.drop"
+,Union[pandas.core.generic.NDFrame.Self,None]
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(
+None*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+labels
+None *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+index
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
 typing.Hashable"typing.HashableW
  typing.Sequence[typing.Hashable]"
-typing.Hashable"typing.Hashable"typing.Sequence *
-columns
-7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index *
+columns
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *-
+inplace
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+drop pandas.core.generic.NDFrame.drop"
+,Union[pandas.core.generic.NDFrame.Self,None]
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(
+None*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+labels
+None *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+index
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
 typing.Hashable"typing.HashableW
  typing.Sequence[typing.Hashable]"
-typing.Hashable"typing.Hashable"typing.Sequence *
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+columns
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *-
+inplace
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+drop pandas.core.generic.NDFrame.drop"
+,Union[pandas.core.generic.NDFrame.Self,None]
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(
+None*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*
+labels
+[Union[typing.Hashable,typing.Sequence[typing.Hashable],pandas.core.indexes.base.Index[Any]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+index
+None *
+columns
+None *
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -1735,7 +2103,34 @@ escapecharD
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXr:
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
+pipe pandas.core.generic.NDFrame.pipe
+pipe pandas.core.generic.NDFrame.pipe"I
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*
+self
+ pandas.core.generic.NDFrame.Self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame(*U
+funcK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+
+args*
+kwargs0:typing.overloadX
+pipe pandas.core.generic.NDFrame.pipe"I
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*D
+self:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+func
+3Tuple[CallableType[builtins.function],builtins.str]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str*
+args
+Any*
+kwargs
+Any0:typing.overloadXr:
 __hash__$pandas.core.generic.NDFrame.__hash__
 Nonerb
 __array_priority__.pandas.core.generic.NDFrame.__array_priority__
@@ -1743,7 +2138,8 @@ escapecharD
 __annotations__#pandas.core.generic.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict*
+Any"
builtins.dict*
+dtdatetime *
 npnumpy *"
 indexingpandas.core.indexing *5
 
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.generic.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.generic.protobuf
index 3c98fb4072..716d18a479 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.generic.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.generic.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.groupby.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.groupby.protobuf
index c609d3601d..2e932e9bd2 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.groupby.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.groupby.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.grouper.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.grouper.protobuf
index ff0806f6cd..9beaabb907 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.grouper.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.grouper.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.indexing.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.indexing.protobuf
new file mode 100644
index 0000000000..396417af19
--- /dev/null
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.indexing.protobuf
@@ -0,0 +1,103 @@
+
+pandas.core.groupby.indexingZ
+GroupByIndexingMixin1pandas.core.groupby.indexing.GroupByIndexingMixin"builtins.object
+GroupByPositionalSelector6pandas.core.groupby.indexing.GroupByPositionalSelector"builtins.object*
+__getitem__Bpandas.core.groupby.indexing.GroupByPositionalSelector.__getitem__"
+AUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any]]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*rp
+6pandas.core.groupby.indexing.GroupByPositionalSelector"6pandas.core.groupby.indexing.GroupByPositionalSelector*
+Union[TypeAlias[Union[TypeAlias[Union[builtins.int,numpy.integer[Any]]],TypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]]],builtins.tuple[Any]]
+TypeAlias[Union[TypeAlias[Union[builtins.int,numpy.integer[Any]]],TypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]]]
+Union[TypeAlias[Union[builtins.int,numpy.integer[Any]]],TypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]]
+1TypeAlias[Union[builtins.int,numpy.integer[Any]]]v
+&Union[builtins.int,numpy.integer[Any]]
+builtins.int"builtins.int,
+numpy.integer[Any]
+Any"
numpy.integer"pandas._typing.ScalarIndexer
+STypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]
+HUnion[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]] 
+builtins.slice"builtins.sliceJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.SequenceIndexer" pandas._typing.PositionalIndexer.
+builtins.tuple[Any]
+Any"builtins.tupler
+groupby_objectEpandas.core.groupby.indexing.GroupByPositionalSelector.groupby_objectX
+(pandas.core.groupby.groupby.GroupBy[Any]
+Any"#pandas.core.groupby.groupby.GroupBy
+GroupByNthSelector/pandas.core.groupby.indexing.GroupByNthSelector"builtins.object*
+__call__8pandas.core.groupby.indexing.GroupByNthSelector.__call__"
+AUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any]]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+Wpandas.core.groupby.indexing.GroupByNthSelector[pandas.core.groupby.indexing._GroupByT]
+&pandas.core.groupby.indexing._GroupByTX
+(pandas.core.groupby.groupby.GroupBy[Any]
+Any"#pandas.core.groupby.groupby.GroupBy"#pandas.core.groupby.groupby.GroupBy"/pandas.core.groupby.indexing.GroupByNthSelector*	
+n
+Union[TypeAlias[Union[TypeAlias[Union[builtins.int,numpy.integer[Any]]],TypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]]],builtins.tuple[Any]]
+TypeAlias[Union[TypeAlias[Union[builtins.int,numpy.integer[Any]]],TypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]]]
+Union[TypeAlias[Union[builtins.int,numpy.integer[Any]]],TypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]]
+1TypeAlias[Union[builtins.int,numpy.integer[Any]]]v
+&Union[builtins.int,numpy.integer[Any]]
+builtins.int"builtins.int,
+numpy.integer[Any]
+Any"
numpy.integer"pandas._typing.ScalarIndexer
+STypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]
+HUnion[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]] 
+builtins.slice"builtins.sliceJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.SequenceIndexer" pandas._typing.PositionalIndexer.
+builtins.tuple[Any]
+Any"builtins.tuple*
+dropna
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+__getitem__;pandas.core.groupby.indexing.GroupByNthSelector.__getitem__"
+AUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any]]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+Wpandas.core.groupby.indexing.GroupByNthSelector[pandas.core.groupby.indexing._GroupByT]
+&pandas.core.groupby.indexing._GroupByTX
+(pandas.core.groupby.groupby.GroupBy[Any]
+Any"#pandas.core.groupby.groupby.GroupBy"#pandas.core.groupby.groupby.GroupBy"/pandas.core.groupby.indexing.GroupByNthSelector*
+Union[TypeAlias[Union[TypeAlias[Union[builtins.int,numpy.integer[Any]]],TypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]]],builtins.tuple[Any]]
+TypeAlias[Union[TypeAlias[Union[builtins.int,numpy.integer[Any]]],TypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]]]
+Union[TypeAlias[Union[builtins.int,numpy.integer[Any]]],TypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]]
+1TypeAlias[Union[builtins.int,numpy.integer[Any]]]v
+&Union[builtins.int,numpy.integer[Any]]
+builtins.int"builtins.int,
+numpy.integer[Any]
+Any"
numpy.integer"pandas._typing.ScalarIndexer
+STypeAlias[Union[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]]]
+HUnion[builtins.slice,builtins.list[builtins.int],numpy.ndarray[Any,Any]] 
+builtins.slice"builtins.sliceJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.SequenceIndexer" pandas._typing.PositionalIndexer.
+builtins.tuple[Any]
+Any"builtins.tuplePr
+groupby_object>pandas.core.groupby.indexing.GroupByNthSelector.groupby_object
+&pandas.core.groupby.indexing._GroupByTX
+(pandas.core.groupby.groupby.GroupBy[Any]
+Any"#pandas.core.groupby.groupby.GroupBy"#pandas.core.groupby.groupby.GroupBy*
+__annotations__,pandas.core.groupby.indexing.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.ops.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.ops.protobuf
index 49e95eda60..3b72bd8ef1 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.ops.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.ops.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.protobuf
index 850d3a6616..f3c9464656 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.groupby.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.accessors.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.accessors.protobuf
index e0776573be..10f586ce93 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.accessors.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.accessors.protobuf
@@ -216,14 +216,14 @@ bpandas.core.indexes.accessors._DatetimeBoolOps[pandas.core.indexes.accessors._D
 7pandas.core.indexes.accessors._DTOtherOpsTimeReturnType"
 builtins.object"builtins.object"builtins.object"/pandas.core.indexes.accessors._DatetimeOtherOps0:builtins.property`P
 DatetimeAndPeriodProperties9pandas.core.indexes.accessors.DatetimeAndPeriodProperties"/pandas.core.indexes.accessors._DatetimeFieldOps
-_DatetimeLikeOps.pandas.core.indexes.accessors._DatetimeLikeOps"/pandas.core.indexes.accessors._DatetimeFieldOps"0pandas.core.indexes.accessors._DatetimeObjectOps".pandas.core.indexes.accessors._DatetimeBoolOps"/pandas.core.indexes.accessors._DatetimeOtherOpsP0
-_DatetimeRoundingMethods6pandas.core.indexes.accessors._DatetimeRoundingMethods"builtins.object*
-roundpandas.core.indexes.accessors.DatetimeProperties.to_pydatetime"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-pandas.core.indexes.accessors.DatetimeProperties[pandas.core.indexes.accessors._DTFieldOpsReturnType,pandas.core.indexes.accessors._DTBoolOpsReturnType,pandas.core.indexes.accessors._DTRoundingMethodReturnType,pandas.core.indexes.accessors._DTOtherOpsDateReturnType,pandas.core.indexes.accessors._DTOtherOpsTimeReturnType,pandas.core.indexes.accessors._DTFreqReturnType,pandas.core.indexes.accessors._DTNormalizeReturnType,pandas.core.indexes.accessors._DTStrKindReturnType,pandas.core.indexes.accessors._DTToPeriodReturnType]l
+Any"
numpy.ndarray*
+self
+pandas.core.indexes.accessors.DatetimeProperties[pandas.core.indexes.accessors._DTFieldOpsReturnType,pandas.core.indexes.accessors._DTBoolOpsReturnType,pandas.core.indexes.accessors._DTTimestampTimedeltaReturnType,pandas.core.indexes.accessors._DTOtherOpsDateReturnType,pandas.core.indexes.accessors._DTOtherOpsTimeReturnType,pandas.core.indexes.accessors._DTFreqReturnType,pandas.core.indexes.accessors._DTNormalizeReturnType,pandas.core.indexes.accessors._DTStrKindReturnType,pandas.core.indexes.accessors._DTToPeriodReturnType]l
 3pandas.core.indexes.accessors._DTFieldOpsReturnType"
 builtins.object"builtins.object"builtins.objectk
 2pandas.core.indexes.accessors._DTBoolOpsReturnType"
-builtins.object"builtins.object"builtins.objectr
-9pandas.core.indexes.accessors._DTRoundingMethodReturnType"
+builtins.object"builtins.object"builtins.objectv
+=pandas.core.indexes.accessors._DTTimestampTimedeltaReturnType"
 builtins.object"builtins.object"builtins.objectp
 7pandas.core.indexes.accessors._DTOtherOpsDateReturnType"
 builtins.object"builtins.object"builtins.objectp
@@ -502,16 +506,16 @@ month_nameApandas.core.indexes.accessors._DatetimeLikeNoTZMethods.month_name"k
 2pandas.core.indexes.accessors._DTStrKindReturnType"
 builtins.object"builtins.object"builtins.objectl
 3pandas.core.indexes.accessors._DTToPeriodReturnType"
-builtins.object"builtins.object"builtins.object"0pandas.core.indexes.accessors.DatetimeProperties*
+builtins.object"builtins.object"builtins.object"0pandas.core.indexes.accessors.DatetimeProperties*
 isocalendar
+rename%pandas.core.indexes.base.Index.rename)
+rename%pandas.core.indexes.base.Index.rename"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6193,18 +5892,58 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+name
+Any*I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+rename%pandas.core.indexes.base.Index.rename"
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6231,35 +5970,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*		
-Union[builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],typing.Sequence[builtins.int],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[builtins.bool],typing.Sequence[builtins.bool],TypeAlias[Unknown]] 
-builtins.slice"builtins.slice
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Indexe
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.SeriesQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence8
-TypeAlias[Unknown]"pandas._typing.np_ndarray_bool0:typing.overloadX4
-__getitem__*pandas.core.indexes.base.Index.__getitem__"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+name
+Any*G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX2_
+__getitem__*pandas.core.indexes.base.Index.__getitem__2
+__getitem__*pandas.core.indexes.base.Index.__getitem__"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6286,17 +6012,15 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6323,38 +6047,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-Union[builtins.int,builtins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]]
-builtins.int"builtins.int
-nbuiltins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*		
+Union[builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],typing.Sequence[builtins.int],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[builtins.bool],typing.Sequence[builtins.bool],TypeAlias[Unknown]] 
+builtins.slice"builtins.slice
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyint"builtins.tuple0:typing.overloadX24
-__mul__&pandas.core.indexes.base.Index.__mul__
-__mul__&pandas.core.indexes.base.Index.__mul__"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Index[builtins.float]]l
-,pandas.core.indexes.base.Index[builtins.int]
-builtins.int"builtins.int"pandas.core.indexes.base.Indexr
-.pandas.core.indexes.base.Index[builtins.float] 
-builtins.float"builtins.float"pandas.core.indexes.base.Index**(
-datetime.timedelta"datetime.timedelta0:typing.overloadX/
-__mul__&pandas.core.indexes.base.Index.__mul__"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Indexe
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.SeriesQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence8
+TypeAlias[Unknown]"pandas._typing.np_ndarray_bool0:typing.overloadX-
+__getitem__*pandas.core.indexes.base.Index.__getitem__"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6381,18 +6099,14 @@ bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Ind
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6419,30 +6133,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*	
-Any0:typing.overloadX23
-__truediv__*pandas.core.indexes.base.Index.__truediv__
-__truediv__*pandas.core.indexes.base.Index.__truediv__"
-NoReturn
-*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+Union[builtins.int,builtins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]]
+builtins.int"builtins.int
+nbuiltins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyint"builtins.tuple0:typing.overloadX2-
+__mul__&pandas.core.indexes.base.Index.__mul__
+__mul__&pandas.core.indexes.base.Index.__mul__"^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
 bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Index[builtins.float]]l
 ,pandas.core.indexes.base.Index[builtins.int]
 builtins.int"builtins.int"pandas.core.indexes.base.Indexr
 .pandas.core.indexes.base.Index[builtins.float] 
 builtins.float"builtins.float"pandas.core.indexes.base.Index**(
-datetime.timedelta"datetime.timedelta0:typing.overloadX/
-__truediv__*pandas.core.indexes.base.Index.__truediv__"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+datetime.timedelta"datetime.timedelta0:typing.overloadX(
+__mul__&pandas.core.indexes.base.Index.__mul__"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6469,18 +6188,15 @@ bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Ind
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6507,14 +6223,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*	
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*	
 Any0:typing.overloadXPr=
 __hash__'pandas.core.indexes.base.Index.__hash__
 NonerW
@@ -6523,13 +6236,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 notnull&pandas.core.indexes.base.Index.notnull&
 builtins.ellipsis"builtins.ellipsisr[
 __bool__'pandas.core.indexes.base.Index.__bool__&
-builtins.ellipsis"builtins.ellipsis
-CategoricalIndex-pandas.core.indexes.category.CategoricalIndex",pandas.core.indexes.extension.ExtensionIndex"#pandas.core.accessor.PandasDelegate*I
-__new__5pandas.core.indexes.category.CategoricalIndex.__new__"
-2pandas.core.indexes.category.CategoricalIndex.Self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.ellipsis"builtins.ellipsis
+CategoricalIndex-pandas.core.indexes.category.CategoricalIndex",pandas.core.indexes.extension.ExtensionIndex"#pandas.core.accessor.PandasDelegate*>
+__new__5pandas.core.indexes.category.CategoricalIndex.__new__"
+2pandas.core.indexes.category.CategoricalIndex.Self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6556,20 +6269,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex(*
-cls
-8Type[pandas.core.indexes.category.CategoricalIndex.Self]
-2pandas.core.indexes.category.CategoricalIndex.Self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex(*
+cls
+8Type[pandas.core.indexes.category.CategoricalIndex.Self]
+2pandas.core.indexes.category.CategoricalIndex.Self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6596,18 +6306,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex("type*
-data
-"typing.Iterable[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex("type*
+data
+"typing.Iterable[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6634,14 +6341,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Iterable *
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterable *
 
 categories
 Any *
@@ -6655,13 +6359,13 @@ categories
 Any *S
 equals4pandas.core.indexes.category.CategoricalIndex.equals*
 self*	
-other*
+other*
 
inferred_type;pandas.core.indexes.category.CategoricalIndex.inferred_type"
-builtins.str"builtins.str*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6688,21 +6392,18 @@ categories
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*_
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*_
 values4pandas.core.indexes.category.CategoricalIndex.values*
-self0:builtins.property`*
+self0:builtins.property`*
 __contains__:pandas.core.indexes.category.CategoricalIndex.__contains__"
-
builtins.bool"
builtins.bool*
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6729,23 +6430,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*	
-Any*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*	
+Any*
 	__array__7pandas.core.indexes.category.CategoricalIndex.__array__"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6772,23 +6470,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 dtype
-Any *&
+Any *#
 astype4pandas.core.indexes.category.CategoricalIndex.astype"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6815,14 +6510,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 dtype
 TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
 Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
@@ -6849,13 +6541,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fillna4pandas.core.indexes.category.CategoricalIndex.fillna*
 self*
 value *
-downcast *
+downcast *
 	is_unique7pandas.core.indexes.category.CategoricalIndex.is_unique"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6882,20 +6574,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
 is_monotonic_increasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_increasing"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6922,20 +6611,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
 is_monotonic_decreasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_decreasing"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6962,24 +6648,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*U
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*U
 unique4pandas.core.indexes.category.CategoricalIndex.unique*
 self*
-level *
+level *
 
 duplicated8pandas.core.indexes.category.CategoricalIndex.duplicated"
-Any*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7006,14 +6689,11 @@ duplicated8pandas.core.indexes.category.CategoricalIndex.duplicated"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 keep
 IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
@@ -7021,14 +6701,7 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
 builtins.str"builtins.str:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *S
-get_loc5pandas.core.indexes.category.CategoricalIndex.get_loc*
-self*
-key*l
-	get_value7pandas.core.indexes.category.CategoricalIndex.get_value*
-self*
-seriesArrayLike*
-key*]
+
builtins.bool"
builtins.bool *]
 where3pandas.core.indexes.category.CategoricalIndex.where*
 self*
 cond*
@@ -7051,16 +6724,7 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 get_indexer_non_uniqueDpandas.core.indexes.category.CategoricalIndex.get_indexer_non_unique*
 self*
 
-target*`
-take_nd5pandas.core.indexes.category.CategoricalIndex.take_nd*
-self*
-args*
-
-kwargs*N
-map1pandas.core.indexes.category.CategoricalIndex.map*
-self*
-
-mapper*Q
+target*Q
 delete4pandas.core.indexes.category.CategoricalIndex.delete*
 self*
 loc*[
@@ -7075,8 +6739,8 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 
 categories8pandas.core.indexes.category.CategoricalIndex.categoriesN
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexA
-
DatetimeIndex+pandas.core.indexes.datetimes.DatetimeIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"5pandas.core.indexes.accessors.DatetimeIndexProperties*
+Any"pandas.core.indexes.base.Index>
+
DatetimeIndex+pandas.core.indexes.datetimes.DatetimeIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"5pandas.core.indexes.accessors.DatetimeIndexProperties*
 __init__4pandas.core.indexes.datetimes.DatetimeIndex.__init__"
 None*d
 selfZ
@@ -7105,10 +6769,6 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 freq
 Any *
 tz
-Any */
-	normalize
-
builtins.bool"
builtins.bool *
-closed
 Any *-
 	ambiguous
 builtins.str"builtins.str *.
@@ -7132,13 +6792,11 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 Any *N
 
 __reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
-self*
+self*
 	to_series5pandas.core.indexes.datetimes.DatetimeIndex.to_series"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*d
 selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-keep_tz
-Any *
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
 index
 Any *
 name
@@ -7148,16 +6806,7 @@ __reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
 selfZ
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*(
 freq
-builtins.str"builtins.str *a
-	get_value5pandas.core.indexes.datetimes.DatetimeIndex.get_value*
-self*
-
-series*
-key*b
-get_loc3pandas.core.indexes.datetimes.DatetimeIndex.get_loc*
-self*
-key*
-	tolerance *x
+builtins.str"builtins.str *x
 
slice_indexer9pandas.core.indexes.datetimes.DatetimeIndex.slice_indexer*
 self*
 start *	
@@ -7173,13 +6822,7 @@ __reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
 side
 builtins.str"builtins.str *
 sorter
-Any *
-is_type_compatible>pandas.core.indexes.datetimes.DatetimeIndex.is_type_compatible"
-
builtins.bool"
builtins.bool*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-typ
-Any*
+Any *
 
inferred_type9pandas.core.indexes.datetimes.DatetimeIndex.inferred_type"
 builtins.str"builtins.str*d
 selfZ
@@ -7208,13 +6851,7 @@ start_time
 
include_start
 
builtins.bool"
builtins.bool *1
 include_end
-
builtins.bool"
builtins.bool *
-to_perioddelta:pandas.core.indexes.datetimes.DatetimeIndex.to_perioddelta"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-freq
-Any*
+
builtins.bool"
builtins.bool *
 to_julian_date:pandas.core.indexes.datetimes.DatetimeIndex.to_julian_date"r
 .pandas.core.indexes.base.Index[builtins.float] 
 builtins.float"builtins.float"pandas.core.indexes.base.Index*d
@@ -7236,35 +6873,40 @@ AUnion[numpy.dtype[Any],pandas.core.dtypes.dtypes.DatetimeTZDtype](
 Any"numpy.dtypeV
 )pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype*d
 selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`2
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`2
 __add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__
 __add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
 __add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-]Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex]T
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+Union[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.offsets.BaseOffset](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX2
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX2
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-]Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex]T
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+Union[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.offsets.BaseOffset](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-[Union[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]T
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+mUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
 
IntervalIndex*pandas.core.indexes.interval.IntervalIndex",pandas.core.indexes.extension.ExtensionIndex"#pandas._libs.interval.IntervalMixin*
 __new__2pandas.core.indexes.interval.IntervalIndex.__new__"
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
@@ -7480,27 +7122,6 @@ Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-	get_value4pandas.core.indexes.interval.IntervalIndex.get_value"
-Any*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-series
-/TypeAlias[Type[pandas.core.series.Series[Any]]]t
-$Type[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"type"$pandas.core.dtypes.generic.ABCSeries*
-key
-Any*
-is_all_dates7pandas.core.indexes.interval.IntervalIndex.is_all_dates"
-
builtins.bool"
builtins.bool*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
 Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`2Z
 from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks
 from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
@@ -8347,7 +7968,7 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedTypeئ
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType
 
 MultiIndex$pandas.core.indexes.multi.MultiIndex"pandas.core.indexes.base.Index*
 __new__,pandas.core.indexes.multi.MultiIndex.__new__"
@@ -8571,10 +8192,6 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*S
 
builtins.bool"
builtins.bool *
 __len__,pandas.core.indexes.multi.MultiIndex.__len__"
 builtins.int"builtins.int*NL
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
-
inferred_type2pandas.core.indexes.multi.MultiIndex.inferred_type"
-builtins.str"builtins.str*V
-selfL
 $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*V
 values+pandas.core.indexes.multi.MultiIndex.values*
 self0:builtins.property`*
@@ -8618,12 +8235,7 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pan
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *Z
-	get_value.pandas.core.indexes.multi.MultiIndex.get_value*
-self*
-
-series*
-key*
+builtins.str"builtins.str *
 get_level_values5pandas.core.indexes.multi.MultiIndex.get_level_values"N
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.Index*V
@@ -8649,11 +8261,7 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*+
 allow_duplicates
 
builtins.bool"
builtins.bool *M
 
to_flat_index2pandas.core.indexes.multi.MultiIndex.to_flat_index*
-self*
-is_all_dates1pandas.core.indexes.multi.MultiIndex.is_all_dates"
-
builtins.bool"
builtins.bool*V
-selfL
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex0:builtins.property`*[
+self*[
 remove_unused_levels9pandas.core.indexes.multi.MultiIndex.remove_unused_levels*
 self*
 nlevels,pandas.core.indexes.multi.MultiIndex.nlevels"
@@ -8771,10 +8379,7 @@ slice_locs/pandas.core.indexes.multi.MultiIndex.slice_locs*
 start *	
 end *
 
-step *J
-get_loc,pandas.core.indexes.multi.MultiIndex.get_loc*
-self*
-key*
+step *
 
get_loc_level2pandas.core.indexes.multi.MultiIndex.get_loc_level"
 Any*V
 selfL
@@ -8806,13 +8411,18 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
 self*	
 other*
 
-sort *
+sort *
 intersection1pandas.core.indexes.multi.MultiIndex.intersection"
-Any*V
-selfL
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
-other
-Any**
+Any*
+self
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(*
+other
+CUnion[builtins.list[Any],pandas.core.indexes.multi.MultiIndex.Self],
+builtins.list[Any]
+Any"
builtins.list
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(**
 sort
 
builtins.bool"
builtins.bool *^
 
@@ -8899,7 +8509,7 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.tuple[Any]
 Any"builtins.tuple*NL
 $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
-builtins.int"builtins.int0:typing.overloadXA
+builtins.int"builtins.int0:typing.overloadX=
 PeriodIndex&pandas.core.indexes.period.PeriodIndex"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin"1pandas.core.indexes.accessors.PeriodIndexFieldOps*
 __new__.pandas.core.indexes.period.PeriodIndex.__new__"
 Any*
@@ -8972,12 +8582,7 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
 
inferred_type4pandas.core.indexes.period.PeriodIndex.inferred_type"
 builtins.str"builtins.str*Z
 selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`*\
-	get_value0pandas.core.indexes.period.PeriodIndex.get_value*
-self*
-
-series*
-key*
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`*
 get_indexer2pandas.core.indexes.period.PeriodIndex.get_indexer*
 self*
 
@@ -8988,11 +8593,7 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
 get_indexer_non_unique=pandas.core.indexes.period.PeriodIndex.get_indexer_non_unique*
 self*
 
-target*]
-get_loc.pandas.core.indexes.period.PeriodIndex.get_loc*
-self*
-key*
-	tolerance *T
+target*T
 insert-pandas.core.indexes.period.PeriodIndex.insert*
 self*
 loc*
@@ -9010,14 +8611,6 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
 return_indexers
 
builtins.bool"
builtins.bool **
 sort
-
builtins.bool"
builtins.bool *
-intersection3pandas.core.indexes.period.PeriodIndex.intersection"
-Any*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-other
-Any**
-sort
 
builtins.bool"
builtins.bool *`
 
 difference1pandas.core.indexes.period.PeriodIndex.difference*
@@ -9092,36 +8685,19 @@ difference1pandas.core.indexes.period.PeriodIndex.difference*
 __rsub__/pandas.core.indexes.period.PeriodIndex.__rsub__"J
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*RP
 &pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*LJ
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadXI
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadXC
 
-RangeIndex$pandas.core.indexes.range.RangeIndex"pandas.core.indexes.base.Index*
+RangeIndex$pandas.core.indexes.range.RangeIndex"pandas.core.indexes.base.Index*
 __new__,pandas.core.indexes.range.RangeIndex.__new__"
 Any*
 cls
 *Type[pandas.core.indexes.range.RangeIndex]L
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex"type*
-start
-8Union[builtins.int,pandas.core.indexes.range.RangeIndex]
-builtins.int"builtins.intL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex *(
-stop
-builtins.int"builtins.int *(
-step
-builtins.int"builtins.int *
-dtype
-Any **
-copy
-
builtins.bool"
builtins.bool *
-name
-Any *
-__init__-pandas.core.indexes.range.RangeIndex.__init__"
-None*V
-selfL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex*
-start
-8Union[builtins.int,pandas.core.indexes.range.RangeIndex]
+$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex"type*
+start
+GUnion[builtins.int,pandas.core.indexes.range.RangeIndex,builtins.range]
 builtins.int"builtins.intL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex *(
+$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex 
+builtins.range"builtins.range *(
 stop
 builtins.int"builtins.int *(
 step
@@ -9185,11 +8761,7 @@ $pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex*xv
 &Union[builtins.int,numpy.integer[Any]]
 builtins.int"builtins.int,
 numpy.integer[Any]
-Any"
numpy.integer*[
-get_loc,pandas.core.indexes.range.RangeIndex.get_loc*
-self*
-key*
-	tolerance *
+Any"
numpy.integer*
 get_indexer0pandas.core.indexes.range.RangeIndex.get_indexer*
 self*
 
@@ -9257,15 +8829,7 @@ $pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex**
 
builtins.bool"
builtins.bool *J
 equals+pandas.core.indexes.range.RangeIndex.equals*
 self*	
-other*
-intersection1pandas.core.indexes.range.RangeIndex.intersection"
-Any*V
-selfL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex*
-other
-Any**
-sort
-
builtins.bool"
builtins.bool *
+other*
 join)pandas.core.indexes.range.RangeIndex.join"
 Any*V
 selfL
@@ -9340,8 +8904,8 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 __getitem__0pandas.core.indexes.range.RangeIndex.__getitem__"
 builtins.int"builtins.int*NL
 $pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex*
-builtins.int"builtins.int0:typing.overloadXA
-TimedeltaIndex-pandas.core.indexes.timedeltas.TimedeltaIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"6pandas.core.indexes.accessors.TimedeltaIndexProperties*
+builtins.int"builtins.int0:typing.overloadXT
+TimedeltaIndex-pandas.core.indexes.timedeltas.TimedeltaIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"6pandas.core.indexes.accessors.TimedeltaIndexProperties*
 __new__5pandas.core.indexes.timedeltas.TimedeltaIndex.__new__"
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
@@ -9367,23 +8931,7 @@ cUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedel
 datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta&
 numpy.timedelta64"numpy.timedelta64 
-builtins.float"builtins.float"typing.Sequence *
-unit
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *
+builtins.float"builtins.float"typing.Sequence *
 freq
 :Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.strP
@@ -9396,19 +8944,21 @@ cUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedel
 copy
 
builtins.bool"
builtins.bool *(
 name
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 __radd__6pandas.core.indexes.timedeltas.TimedeltaIndex.__radd__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*`^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-[Union[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]T
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+mUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
 __sub__5pandas.core.indexes.timedeltas.TimedeltaIndex.__sub__"
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
-bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self]T
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+uUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
@@ -9417,13 +8967,23 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*&$
-builtins.complex"builtins.complex*
-__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__"
-2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
-2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*&$
-builtins.complex"builtins.complex*
+builtins.complex"builtins.complex*
+__rtruediv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__rtruediv__"r
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence*
+
__rfloordiv__;pandas.core.indexes.timedeltas.TimedeltaIndex.__rfloordiv__"l
+,pandas.core.indexes.base.Index[builtins.int]
+builtins.int"builtins.int"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence*
 astype4pandas.core.indexes.timedeltas.TimedeltaIndex.astype"
 Any*h
 self^
@@ -9431,16 +8991,7 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 dtype
 Any**
 copy
-
builtins.bool"
builtins.bool *c
-	get_value7pandas.core.indexes.timedeltas.TimedeltaIndex.get_value*
-self*
-
-series*
-key*d
-get_loc5pandas.core.indexes.timedeltas.TimedeltaIndex.get_loc*
-self*
-key*
-	tolerance *
+
builtins.bool"
builtins.bool *
 searchsorted:pandas.core.indexes.timedeltas.TimedeltaIndex.searchsorted"
 Any*h
 self^
@@ -9466,7 +9017,7 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 index
 Any *
 name
-Any 2
+Any 2
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__"P
 &pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*`^
@@ -9475,16 +9026,55 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*`^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__"
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
-bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self]T
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+uUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(0:typing.overloadX
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(0:typing.overloadX2
+
+__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__
+__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__"
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+7Union[builtins.complex,typing.Sequence[builtins.float]]$
+builtins.complex"builtins.complexT
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence0:typing.overloadX
+__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__"r
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence0:typing.overloadX2
+
+__floordiv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__floordiv__
+__floordiv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__floordiv__"
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+7Union[builtins.complex,typing.Sequence[builtins.float]]$
+builtins.complex"builtins.complexT
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence0:typing.overloadX
+__floordiv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__floordiv__"l
+,pandas.core.indexes.base.Index[builtins.int]
+builtins.int"builtins.int"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence0:typing.overloadX
 get_objs_combined_axis.pandas.core.indexes.api.get_objs_combined_axis"N
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.Index*
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.base.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.base.protobuf
index f75ccda37d..77fc74214c 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.base.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.base.protobuf
@@ -1,13 +1,13 @@
 
 pandas.core.indexes.baseS
-InvalidIndexError*pandas.core.indexes.base.InvalidIndexError"builtins.Exceptionف
-Indexpandas.core.indexes.base.Index"pandas.core.base.IndexOpsMixin*1
-str"pandas.core.indexes.base.Index.str"
-kpandas.core.strings.StringMethods[pandas.core.indexes.base.Index.Self,pandas.core.indexes.multi.MultiIndex]
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+InvalidIndexError*pandas.core.indexes.base.InvalidIndexError"builtins.Exception
+Indexpandas.core.indexes.base.Index"pandas.core.base.IndexOpsMixin*/
+str"pandas.core.indexes.base.Index.str"
+pandas.core.strings.StringMethods[pandas.core.indexes.base.Index.Self,pandas.core.indexes.multi.MultiIndex,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34,66 +34,24 @@ kpandas.core.strings.StringMethods[pandas.core.indexes.base.Index.Self,pandas.co
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(L
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"!pandas.core.strings.StringMethods*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(0:builtins.property`*
-asi8#pandas.core.indexes.base.Index.asi8"
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(L
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_int64*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool"!pandas.core.strings.StringMethods*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -120,20 +78,17 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(0:builtins.property`*
 is_"pandas.core.indexes.base.Index.is_"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -160,21 +115,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
-Any*
+Any*
 __len__&pandas.core.indexes.base.Index.__len__"
-builtins.int"builtins.int*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -201,22 +153,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 	__array__(pandas.core.indexes.base.Index.__array__"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -243,31 +192,28 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 dtype
 Any *d
 __array_wrap__-pandas.core.indexes.base.Index.__array_wrap__*
 self*
 
 result*
-context *
+context *
 dtype$pandas.core.indexes.base.Index.dtype"
 STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
 HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 numpy.dtype[numpy.generic]
 
numpy.generic"
numpy.generic"numpy.dtypeP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -294,20 +240,17 @@ HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 ravel$pandas.core.indexes.base.Index.ravel"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -334,26 +277,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*)
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*)
 order
 builtins.str"builtins.str *@
 view#pandas.core.indexes.base.Index.view*
 self*	
-cls *&
+cls *"
 astype%pandas.core.indexes.base.Index.astype"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -380,14 +320,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 dtype
 TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
 Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
@@ -410,13 +347,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 typing.Mapping[Any,Unknown]
 Any"typing.Mapping"pandas._typing.DtypeArg**
 copy
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 take#pandas.core.indexes.base.Index.take"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -443,14 +380,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 indices
 Any*(
 axis
@@ -467,12 +401,12 @@ fill_value
 self*
 repeats*
 
-axis *0
-copy#pandas.core.indexes.base.Index.copy"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+axis *(
+copy#pandas.core.indexes.base.Index.copy"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -499,19 +433,16 @@ fill_value
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -538,14 +469,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 name
 Any **
 deep
@@ -557,14 +485,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 __deepcopy__+pandas.core.indexes.base.Index.__deepcopy__*
 self*
 
-memo *
+memo *
 format%pandas.core.indexes.base.Index.format"J
 builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"
builtins.list*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -591,14 +519,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index**
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index**
 name
 
builtins.bool"
builtins.bool *
 	formatter
@@ -607,21 +532,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.function"builtins.function
 None **
 na_rep
-builtins.str"builtins.str *e
-to_native_types.pandas.core.indexes.base.Index.to_native_types*
-self*
-slicer *
-
-kwargs*G
+builtins.str"builtins.str *G
 
to_flat_index,pandas.core.indexes.base.Index.to_flat_index*
-self*
+self*
 	to_series(pandas.core.indexes.base.Index.to_series"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -648,24 +568,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 index
 Any *
 name
-Any *
+Any *
 to_frame'pandas.core.indexes.base.Index.to_frame":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -692,24 +609,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*+
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*+
 index
 
builtins.bool"
builtins.bool *
 name
-Any *
+Any *
 	set_names(pandas.core.indexes.base.Index.set_names"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -736,70 +650,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 names
 Any*
 level
 Any *-
 inplace
-
builtins.bool"
builtins.bool *
-rename%pandas.core.indexes.base.Index.rename"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-name
-Any*-
-inplace
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 nlevels&pandas.core.indexes.base.Index.nlevels"
-builtins.int"builtins.int*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -826,20 +693,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 	sortlevel(pandas.core.indexes.base.Index.sortlevel"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -866,27 +730,24 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 level
 Any */
 	ascending
 
builtins.bool"
builtins.bool *
 sort_remaining
-Any *
+Any *
 get_level_values/pandas.core.indexes.base.Index.get_level_values"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -913,24 +774,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*k
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*k
 level`
  Union[builtins.int,builtins.str]
 builtins.int"builtins.int
-builtins.str"builtins.str*
+builtins.str"builtins.str*
 	droplevel(pandas.core.indexes.base.Index.droplevel"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -957,27 +815,24 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 level
 LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
 builtins.int"builtins.int"pandas._typing.Level)
-builtins.list[Unknown]"
builtins.list *
+builtins.list[Unknown]"
builtins.list *
 is_monotonic_increasing6pandas.core.indexes.base.Index.is_monotonic_increasing"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1004,20 +859,17 @@ LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 is_monotonic_decreasing6pandas.core.indexes.base.Index.is_monotonic_decreasing"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1044,20 +896,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 	is_unique(pandas.core.indexes.base.Index.is_unique"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1084,20 +933,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 has_duplicates-pandas.core.indexes.base.Index.has_duplicates"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1124,21 +970,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 
 is_boolean)pandas.core.indexes.base.Index.is_boolean"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1165,21 +1008,18 @@ is_boolean)pandas.core.indexes.base.Index.is_boolean"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 
 is_integer)pandas.core.indexes.base.Index.is_integer"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1206,20 +1046,17 @@ is_integer)pandas.core.indexes.base.Index.is_integer"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 is_floating*pandas.core.indexes.base.Index.is_floating"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1246,21 +1083,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 
 is_numeric)pandas.core.indexes.base.Index.is_numeric"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1287,20 +1121,17 @@ is_numeric)pandas.core.indexes.base.Index.is_numeric"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 	is_object(pandas.core.indexes.base.Index.is_object"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1327,20 +1158,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 is_categorical-pandas.core.indexes.base.Index.is_categorical"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1367,20 +1195,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 is_interval*pandas.core.indexes.base.Index.is_interval"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1407,20 +1232,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-is_mixed'pandas.core.indexes.base.Index.is_mixed"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*G
+
holds_integer,pandas.core.indexes.base.Index.holds_integer*
+self*
+
inferred_type,pandas.core.indexes.base.Index.inferred_type"
+builtins.str"builtins.str*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1447,27 +1271,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*G
-
holds_integer,pandas.core.indexes.base.Index.holds_integer*
-self*^
-
inferred_type,pandas.core.indexes.base.Index.inferred_type*
-self0:builtins.property`*A
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*A
 
 __reduce__)pandas.core.indexes.base.Index.__reduce__*
-self*
+self*
 hasnans&pandas.core.indexes.base.Index.hasnans"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1494,14 +1311,11 @@ __reduce__)pandas.core.indexes.base.Index.__reduce__*
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*5
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*5
 isna#pandas.core.indexes.base.Index.isna*
 self*7
 notna$pandas.core.indexes.base.Index.notna*
@@ -1509,12 +1323,12 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fillna%pandas.core.indexes.base.Index.fillna*
 self*
 value *
-downcast *0
-dropna%pandas.core.indexes.base.Index.dropna"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+downcast *)
+dropna%pandas.core.indexes.base.Index.dropna"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1541,19 +1355,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1580,25 +1391,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 how
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str */
-unique%pandas.core.indexes.base.Index.unique"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str *(
+unique%pandas.core.indexes.base.Index.unique"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1625,19 +1433,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1664,21 +1469,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 level
-Any *3
-drop_duplicates.pandas.core.indexes.base.Index.drop_duplicates"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any *+
+drop_duplicates.pandas.core.indexes.base.Index.drop_duplicates"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1705,19 +1507,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1744,14 +1543,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 keep
 [Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.bool]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
@@ -1761,7 +1557,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str"pandas._typing.NaPosition:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 
 duplicated)pandas.core.indexes.base.Index.duplicated"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -1770,11 +1566,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1801,14 +1597,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 keep
 IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
@@ -1816,13 +1609,13 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
 builtins.str"builtins.str:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 __and__&pandas.core.indexes.base.Index.__and__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1849,22 +1642,19 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __rand__'pandas.core.indexes.base.Index.__rand__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1891,22 +1681,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __or__%pandas.core.indexes.base.Index.__or__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1933,22 +1720,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __ror__&pandas.core.indexes.base.Index.__ror__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1975,22 +1759,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __xor__&pandas.core.indexes.base.Index.__xor__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2017,22 +1798,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*
+*
 __rxor__'pandas.core.indexes.base.Index.__rxor__"
 NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2059,21 +1837,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 NoReturn
-*/
-__neg__&pandas.core.indexes.base.Index.__neg__"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+*(
+__neg__&pandas.core.indexes.base.Index.__neg__"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2100,18 +1875,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2138,20 +1910,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 __nonzero__*pandas.core.indexes.base.Index.__nonzero__"
-None*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2178,21 +1947,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 union$pandas.core.indexes.base.Index.union"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2219,14 +1985,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
 RUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any]]
 'builtins.list[pandas._typing.HashableT]Q
@@ -2235,12 +1998,12 @@ RUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[An
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.Index*
 sort
-Any *^
-intersection+pandas.core.indexes.base.Index.intersection"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any *P
+intersection+pandas.core.indexes.base.Index.intersection"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2267,19 +2030,16 @@ RUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[An
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2306,19 +2066,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*.
-other.
-KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*'
+other'
+KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2345,18 +2102,15 @@ KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2383,22 +2137,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(**
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(**
 sort
-
builtins.bool"
builtins.bool *1
+
builtins.bool"
builtins.bool **
 
-difference)pandas.core.indexes.base.Index.difference"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+difference)pandas.core.indexes.base.Index.difference"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2425,19 +2176,16 @@ difference)pandas.core.indexes.base.Index.difference"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2464,14 +2212,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 other
 =Union[builtins.list[Any],pandas.core.indexes.base.Index[Any]],
 builtins.list[Any]
@@ -2481,12 +2226,12 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 sortG
 Union[builtins.bool,None]
 
builtins.bool"
builtins.bool
-None *_
-symmetric_difference3pandas.core.indexes.base.Index.symmetric_difference"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *P
+symmetric_difference3pandas.core.indexes.base.Index.symmetric_difference"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2513,19 +2258,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2552,19 +2294,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*.
-other.
-KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*'
+other'
+KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2591,18 +2330,15 @@ KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2629,24 +2365,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 result_name
 Any *
 sort
-Any *
-get_loc&pandas.core.indexes.base.Index.get_loc"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any * 
+get_loc&pandas.core.indexes.base.Index.get_loc"
+Union[builtins.int,builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+builtins.int"builtins.int 
+builtins.slice"builtins.slice
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2673,14 +2415,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 key
 &TypeAlias[Union[typing.Hashable,None]]M
 Union[typing.Hashable,None]"
@@ -2717,13 +2456,13 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 method *
 level *
 limit *
-	tolerance *
+	tolerance *
 join#pandas.core.indexes.base.Index.join"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2750,14 +2489,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
 Any*'
 how
@@ -2767,15 +2503,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 return_indexers
 
builtins.bool"
builtins.bool **
 sort
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 values%pandas.core.indexes.base.Index.values"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2802,20 +2538,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 array$pandas.core.indexes.base.Index.array"P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2842,20 +2575,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 memory_usage+pandas.core.indexes.base.Index.memory_usage"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2882,67 +2612,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index**
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index**
 deep
 
builtins.bool"
builtins.bool *N
 where$pandas.core.indexes.base.Index.where*
 self*
 cond*
-other *
-is_type_compatible1pandas.core.indexes.base.Index.is_type_compatible"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-kind
-Any*
+other *
 __contains__+pandas.core.indexes.base.Index.__contains__"
-
builtins.bool"
builtins.bool*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2969,20 +2654,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*	
-Any*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*	
+Any*
 __setitem__*pandas.core.indexes.base.Index.__setitem__"
-None*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3009,14 +2691,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*	
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*	
 Any*	
 Any*D
 append%pandas.core.indexes.base.Index.append*
@@ -3025,13 +2704,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 putmask&pandas.core.indexes.base.Index.putmask*
 self*
 mask*	
-value*
+value*
 equals%pandas.core.indexes.base.Index.equals"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3058,22 +2737,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
-Any*
+Any*
 	identical(pandas.core.indexes.base.Index.identical"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3100,14 +2776,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 other
 Any*@
 asof#pandas.core.indexes.base.Index.asof*
@@ -3116,13 +2789,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 	asof_locs(pandas.core.indexes.base.Index.asof_locs*
 self*	
 where*
-mask*
+mask*
 sort_values*pandas.core.indexes.base.Index.sort_values"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3149,24 +2822,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*4
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*4
 return_indexer
 
builtins.bool"
builtins.bool */
 	ascending
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 sort#pandas.core.indexes.base.Index.sort"
-None*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3193,24 +2863,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 args
 Any*
 kwargs
-Any*
+Any*
 shift$pandas.core.indexes.base.Index.shift"
-None*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3237,14 +2904,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*+
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*+
 periods
 builtins.int"builtins.int *
 freq
@@ -3253,58 +2917,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 self*
 args*
 
-kwargs*T
-	get_value(pandas.core.indexes.base.Index.get_value*
-self*
-
-series*
-key*
-	set_value(pandas.core.indexes.base.Index.set_value"
-None*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-arr
-Any*
-key
-Any*
-value
-Any*e
+kwargs*e
 get_indexer_non_unique5pandas.core.indexes.base.Index.get_indexer_non_unique*
 self*
 
@@ -3314,17 +2927,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 
 target*
 
-kwargs*
+kwargs*
 groupby&pandas.core.indexes.base.Index.groupby"
 5builtins.dict[typing.Hashable,numpy.ndarray[Any,Any]]"
 typing.Hashable"typing.Hashable9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3351,23 +2964,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 values
-Any*
+Any0:typing.finalP*
 map"pandas.core.indexes.base.Index.map"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3394,18 +3004,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 mapper
 Any*
 	na_action
-Any *
+Any *
 isin#pandas.core.indexes.base.Index.isin"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -3413,11 +3020,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3444,14 +3051,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 values
 Any*
 level
@@ -3479,12 +3083,12 @@ slice_locs)pandas.core.indexes.base.Index.slice_locs*
 insert%pandas.core.indexes.base.Index.insert*
 self*
 loc*
-item*0
-drop#pandas.core.indexes.base.Index.drop"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+item*(
+drop#pandas.core.indexes.base.Index.drop"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3511,19 +3115,16 @@ slice_locs)pandas.core.indexes.base.Index.slice_locs*
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3550,25 +3151,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 labels
 Any**
 errors
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 shape$pandas.core.indexes.base.Index.shape"L
 builtins.tuple[builtins.int]
-builtins.int"builtins.int"builtins.tuple*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"builtins.tuple*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3595,14 +3193,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
 __eq__%pandas.core.indexes.base.Index.__eq__"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -3610,10 +3205,10 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3640,19 +3235,16 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*$"
-builtins.object"builtins.object*.
-__iter__'pandas.core.indexes.base.Index.__iter__"
-"typing.Iterator[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*$"
+builtins.object"builtins.object*&
+__iter__'pandas.core.indexes.base.Index.__iter__"
+"typing.Iterator[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3679,17 +3271,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Iterator*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterator*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3716,14 +3305,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
 __ne__%pandas.core.indexes.base.Index.__ne__"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -3731,10 +3317,10 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3761,15 +3347,12 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*$"
-builtins.object"builtins.object*J
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*$"
+builtins.object"builtins.object*?
 __le__%pandas.core.indexes.base.Index.__le__"
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -3777,11 +3360,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3808,19 +3391,16 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*..
-
+rename%pandas.core.indexes.base.Index.rename)
+rename%pandas.core.indexes.base.Index.rename"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6194,18 +5893,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6232,35 +5929,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*		
-Union[builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],typing.Sequence[builtins.int],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[builtins.bool],typing.Sequence[builtins.bool],TypeAlias[Unknown]] 
-builtins.slice"builtins.slice
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Indexe
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.SeriesQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence8
-TypeAlias[Unknown]"pandas._typing.np_ndarray_bool0:typing.overloadX4
-__getitem__*pandas.core.indexes.base.Index.__getitem__"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+name
+Any*I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+rename%pandas.core.indexes.base.Index.rename"
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6287,17 +5971,22 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+name
+Any*G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX2_
+__getitem__*pandas.core.indexes.base.Index.__getitem__2
+__getitem__*pandas.core.indexes.base.Index.__getitem__"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6324,38 +6013,67 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-Union[builtins.int,builtins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]]
-builtins.int"builtins.int
-nbuiltins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*		
+Union[builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],typing.Sequence[builtins.int],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[builtins.bool],typing.Sequence[builtins.bool],TypeAlias[Unknown]] 
+builtins.slice"builtins.slice
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyint"builtins.tuple0:typing.overloadX24
-__mul__&pandas.core.indexes.base.Index.__mul__
-__mul__&pandas.core.indexes.base.Index.__mul__"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Index[builtins.float]]l
-,pandas.core.indexes.base.Index[builtins.int]
-builtins.int"builtins.int"pandas.core.indexes.base.Indexr
-.pandas.core.indexes.base.Index[builtins.float] 
-builtins.float"builtins.float"pandas.core.indexes.base.Index**(
-datetime.timedelta"datetime.timedelta0:typing.overloadX/
-__mul__&pandas.core.indexes.base.Index.__mul__"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Indexe
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.SeriesQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence8
+TypeAlias[Unknown]"pandas._typing.np_ndarray_bool0:typing.overloadX-
+__getitem__*pandas.core.indexes.base.Index.__getitem__"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6382,18 +6100,14 @@ bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Ind
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6420,30 +6134,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*	
-Any0:typing.overloadX23
-__truediv__*pandas.core.indexes.base.Index.__truediv__
-__truediv__*pandas.core.indexes.base.Index.__truediv__"
-NoReturn
-*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+Union[builtins.int,builtins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]]
+builtins.int"builtins.int
+nbuiltins.tuple[TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyint"builtins.tuple0:typing.overloadX2-
+__mul__&pandas.core.indexes.base.Index.__mul__
+__mul__&pandas.core.indexes.base.Index.__mul__"^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
 bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Index[builtins.float]]l
 ,pandas.core.indexes.base.Index[builtins.int]
 builtins.int"builtins.int"pandas.core.indexes.base.Indexr
 .pandas.core.indexes.base.Index[builtins.float] 
 builtins.float"builtins.float"pandas.core.indexes.base.Index**(
-datetime.timedelta"datetime.timedelta0:typing.overloadX/
-__truediv__*pandas.core.indexes.base.Index.__truediv__"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+datetime.timedelta"datetime.timedelta0:typing.overloadX(
+__mul__&pandas.core.indexes.base.Index.__mul__"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6470,18 +6189,15 @@ bUnion[pandas.core.indexes.base.Index[builtins.int],pandas.core.indexes.base.Ind
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6508,14 +6224,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*	
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*	
 Any0:typing.overloadXPr=
 __hash__'pandas.core.indexes.base.Index.__hash__
 NonerW
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.category.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.category.protobuf
index 4990e0d96c..406444b806 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.category.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.category.protobuf
@@ -1,11 +1,11 @@
 
-pandas.core.indexes.category
-CategoricalIndex-pandas.core.indexes.category.CategoricalIndex",pandas.core.indexes.extension.ExtensionIndex"#pandas.core.accessor.PandasDelegate*I
-__new__5pandas.core.indexes.category.CategoricalIndex.__new__"
-2pandas.core.indexes.category.CategoricalIndex.Self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+pandas.core.indexes.category
+CategoricalIndex-pandas.core.indexes.category.CategoricalIndex",pandas.core.indexes.extension.ExtensionIndex"#pandas.core.accessor.PandasDelegate*>
+__new__5pandas.core.indexes.category.CategoricalIndex.__new__"
+2pandas.core.indexes.category.CategoricalIndex.Self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32,20 +32,17 @@
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex(*
-cls
-8Type[pandas.core.indexes.category.CategoricalIndex.Self]
-2pandas.core.indexes.category.CategoricalIndex.Self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex(*
+cls
+8Type[pandas.core.indexes.category.CategoricalIndex.Self]
+2pandas.core.indexes.category.CategoricalIndex.Self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -72,18 +69,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex("type*
-data
-"typing.Iterable[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex("type*
+data
+"typing.Iterable[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -110,14 +104,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Iterable *
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterable *
 
 categories
 Any *
@@ -131,13 +122,13 @@ categories
 Any *S
 equals4pandas.core.indexes.category.CategoricalIndex.equals*
 self*	
-other*
+other*
 
inferred_type;pandas.core.indexes.category.CategoricalIndex.inferred_type"
-builtins.str"builtins.str*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -164,21 +155,18 @@ categories
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*_
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*_
 values4pandas.core.indexes.category.CategoricalIndex.values*
-self0:builtins.property`*
+self0:builtins.property`*
 __contains__:pandas.core.indexes.category.CategoricalIndex.__contains__"
-
builtins.bool"
builtins.bool*
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -205,23 +193,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*	
-Any*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*	
+Any*
 	__array__7pandas.core.indexes.category.CategoricalIndex.__array__"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -248,23 +233,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 dtype
-Any *&
+Any *#
 astype4pandas.core.indexes.category.CategoricalIndex.astype"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -291,14 +273,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 dtype
 TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
 Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
@@ -325,13 +304,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fillna4pandas.core.indexes.category.CategoricalIndex.fillna*
 self*
 value *
-downcast *
+downcast *
 	is_unique7pandas.core.indexes.category.CategoricalIndex.is_unique"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -358,20 +337,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
 is_monotonic_increasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_increasing"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -398,20 +374,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
 is_monotonic_decreasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_decreasing"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -438,24 +411,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*U
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*U
 unique4pandas.core.indexes.category.CategoricalIndex.unique*
 self*
-level *
+level *
 
 duplicated8pandas.core.indexes.category.CategoricalIndex.duplicated"
-Any*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -482,14 +452,11 @@ duplicated8pandas.core.indexes.category.CategoricalIndex.duplicated"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 keep
 IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
@@ -497,14 +464,7 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
 builtins.str"builtins.str:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *S
-get_loc5pandas.core.indexes.category.CategoricalIndex.get_loc*
-self*
-key*l
-	get_value7pandas.core.indexes.category.CategoricalIndex.get_value*
-self*
-seriesArrayLike*
-key*]
+
builtins.bool"
builtins.bool *]
 where3pandas.core.indexes.category.CategoricalIndex.where*
 self*
 cond*
@@ -527,16 +487,7 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 get_indexer_non_uniqueDpandas.core.indexes.category.CategoricalIndex.get_indexer_non_unique*
 self*
 
-target*`
-take_nd5pandas.core.indexes.category.CategoricalIndex.take_nd*
-self*
-args*
-
-kwargs*N
-map1pandas.core.indexes.category.CategoricalIndex.map*
-self*
-
-mapper*Q
+target*Q
 delete4pandas.core.indexes.category.CategoricalIndex.delete*
 self*
 loc*[
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.datetimelike.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.datetimelike.protobuf
index d2f3ad9ee3..92481c901e 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.datetimelike.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.datetimelike.protobuf
@@ -1,14 +1,14 @@
 
- pandas.core.indexes.datetimelike
-DatetimeIndexOpsMixin6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin",pandas.core.indexes.extension.ExtensionIndex*
+ pandas.core.indexes.datetimelike
+DatetimeIndexOpsMixin6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin",pandas.core.indexes.extension.ExtensionIndex*
 freq;pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.freq"
 2Union[pandas._libs.tslibs.offsets.BaseOffset,None]P
 &pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
-None*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -35,22 +35,19 @@ Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin0:builtins.property`*
 freqstr>pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.freqstr"D
 Union[builtins.str,None]
 builtins.str"builtins.str
-None*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -77,20 +74,17 @@ Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin0:builtins.property`*
 is_all_datesCpandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.is_all_dates"
-
builtins.bool"
builtins.bool*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -117,20 +111,17 @@ Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin0:builtins.property`*
 min:pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.min"
-Any*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -157,14 +148,11 @@ Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
 axis
 Any *,
 skipna
@@ -172,13 +160,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 args
 Any*
 kwargs
-Any*
+Any*
 argmin=pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.argmin"
-Any*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -205,14 +193,11 @@ Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
 axis
 Any *,
 skipna
@@ -220,13 +205,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 args
 Any*
 kwargs
-Any*
+Any*
 max:pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.max"
-Any*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -253,14 +238,11 @@ Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
 axis
 Any *,
 skipna
@@ -268,13 +250,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 args
 Any*
 kwargs
-Any*
+Any*
 argmax=pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.argmax"
-Any*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -301,14 +283,11 @@ Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
 axis
 Any *,
 skipna
@@ -316,12 +295,12 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 args
 Any*
 kwargs
-Any*
+Any*
 __rsub__?pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.__rsub__"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -348,17 +327,143 @@ Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*~
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*~
 ;pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[Any]
-Any"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixinP
-DatetimeTimedeltaMixin7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixinP*
+Any"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixinPG
+DatetimeTimedeltaMixin7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
+unit
+
DatetimeIndex+pandas.core.indexes.datetimes.DatetimeIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"5pandas.core.indexes.accessors.DatetimeIndexProperties*
 __init__4pandas.core.indexes.datetimes.DatetimeIndex.__init__"
 None*d
 selfZ
@@ -29,10 +29,6 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 freq
 Any *
 tz
-Any */
-	normalize
-
builtins.bool"
builtins.bool *
-closed
 Any *-
 	ambiguous
 builtins.str"builtins.str *.
@@ -56,13 +52,11 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 Any *N
 
 __reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
-self*
+self*
 	to_series5pandas.core.indexes.datetimes.DatetimeIndex.to_series"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*d
 selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-keep_tz
-Any *
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
 index
 Any *
 name
@@ -72,16 +66,7 @@ __reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
 selfZ
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*(
 freq
-builtins.str"builtins.str *a
-	get_value5pandas.core.indexes.datetimes.DatetimeIndex.get_value*
-self*
-
-series*
-key*b
-get_loc3pandas.core.indexes.datetimes.DatetimeIndex.get_loc*
-self*
-key*
-	tolerance *x
+builtins.str"builtins.str *x
 
slice_indexer9pandas.core.indexes.datetimes.DatetimeIndex.slice_indexer*
 self*
 start *	
@@ -97,13 +82,7 @@ __reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
 side
 builtins.str"builtins.str *
 sorter
-Any *
-is_type_compatible>pandas.core.indexes.datetimes.DatetimeIndex.is_type_compatible"
-
builtins.bool"
builtins.bool*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-typ
-Any*
+Any *
 
inferred_type9pandas.core.indexes.datetimes.DatetimeIndex.inferred_type"
 builtins.str"builtins.str*d
 selfZ
@@ -132,13 +111,7 @@ start_time
 
include_start
 
builtins.bool"
builtins.bool *1
 include_end
-
builtins.bool"
builtins.bool *
-to_perioddelta:pandas.core.indexes.datetimes.DatetimeIndex.to_perioddelta"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-freq
-Any*
+
builtins.bool"
builtins.bool *
 to_julian_date:pandas.core.indexes.datetimes.DatetimeIndex.to_julian_date"r
 .pandas.core.indexes.base.Index[builtins.float] 
 builtins.float"builtins.float"pandas.core.indexes.base.Index*d
@@ -160,35 +133,40 @@ AUnion[numpy.dtype[Any],pandas.core.dtypes.dtypes.DatetimeTZDtype](
 Any"numpy.dtypeV
 )pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype*d
 selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`2
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`2
 __add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__
 __add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
 __add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-]Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex]T
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+Union[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.offsets.BaseOffset](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX2
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX2
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-]Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex]T
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+Union[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.offsets.BaseOffset](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX
 __sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-[Union[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]T
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+mUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
 
 date_range(pandas.core.indexes.datetimes.date_range"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
@@ -246,9 +224,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *
-unit
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *
+unit
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -256,7 +236,7 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
+builtins.str"builtins.str"pandas._typing.TimeUnit
 None "<
 bdate_range)pandas.core.indexes.datetimes.bdate_range
 bdate_range)pandas.core.indexes.datetimes.bdate_range"Z
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.interval.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.interval.protobuf
index 0831031922..f976147edf 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.interval.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.interval.protobuf
@@ -709,7 +709,7 @@ aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[T
 Any"numpy.dtype
 None*\
 selfR
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype0:builtins.property`
+'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype0:builtins.property`
 
IntervalIndex*pandas.core.indexes.interval.IntervalIndex",pandas.core.indexes.extension.ExtensionIndex"#pandas._libs.interval.IntervalMixin*
 __new__2pandas.core.indexes.interval.IntervalIndex.__new__"
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
@@ -925,27 +925,6 @@ Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
 pandas._typing.IntervalTN
 #pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-	get_value4pandas.core.indexes.interval.IntervalIndex.get_value"
-Any*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-series
-/TypeAlias[Type[pandas.core.series.Series[Any]]]t
-$Type[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"type"$pandas.core.dtypes.generic.ABCSeries*
-key
-Any*
-is_all_dates7pandas.core.indexes.interval.IntervalIndex.is_all_dates"
-
builtins.bool"
builtins.bool*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
 Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`2Z
 from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks
 from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.multi.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.multi.protobuf
index 5a7ef5e38c..497b7a143a 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.multi.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.multi.protobuf
@@ -1,5 +1,5 @@
 
-pandas.core.indexes.multiئ
+pandas.core.indexes.multi
 
 MultiIndex$pandas.core.indexes.multi.MultiIndex"pandas.core.indexes.base.Index*
 __new__,pandas.core.indexes.multi.MultiIndex.__new__"
@@ -223,10 +223,6 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*S
 
builtins.bool"
builtins.bool *
 __len__,pandas.core.indexes.multi.MultiIndex.__len__"
 builtins.int"builtins.int*NL
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
-
inferred_type2pandas.core.indexes.multi.MultiIndex.inferred_type"
-builtins.str"builtins.str*V
-selfL
 $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*V
 values+pandas.core.indexes.multi.MultiIndex.values*
 self0:builtins.property`*
@@ -270,12 +266,7 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pan
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *Z
-	get_value.pandas.core.indexes.multi.MultiIndex.get_value*
-self*
-
-series*
-key*
+builtins.str"builtins.str *
 get_level_values5pandas.core.indexes.multi.MultiIndex.get_level_values"N
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.Index*V
@@ -301,11 +292,7 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*+
 allow_duplicates
 
builtins.bool"
builtins.bool *M
 
to_flat_index2pandas.core.indexes.multi.MultiIndex.to_flat_index*
-self*
-is_all_dates1pandas.core.indexes.multi.MultiIndex.is_all_dates"
-
builtins.bool"
builtins.bool*V
-selfL
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex0:builtins.property`*[
+self*[
 remove_unused_levels9pandas.core.indexes.multi.MultiIndex.remove_unused_levels*
 self*
 nlevels,pandas.core.indexes.multi.MultiIndex.nlevels"
@@ -423,10 +410,7 @@ slice_locs/pandas.core.indexes.multi.MultiIndex.slice_locs*
 start *	
 end *
 
-step *J
-get_loc,pandas.core.indexes.multi.MultiIndex.get_loc*
-self*
-key*
+step *
 
get_loc_level2pandas.core.indexes.multi.MultiIndex.get_loc_level"
 Any*V
 selfL
@@ -458,13 +442,18 @@ $pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
 self*	
 other*
 
-sort *
+sort *
 intersection1pandas.core.indexes.multi.MultiIndex.intersection"
-Any*V
-selfL
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex*
-other
-Any**
+Any*
+self
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(*
+other
+CUnion[builtins.list[Any],pandas.core.indexes.multi.MultiIndex.Self],
+builtins.list[Any]
+Any"
builtins.list
+)pandas.core.indexes.multi.MultiIndex.SelfL
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex(**
 sort
 
builtins.bool"
builtins.bool *^
 
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.period.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.period.protobuf
index 53fc513ebd..5c4b5c89ff 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.period.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.period.protobuf
@@ -1,363 +1,5 @@
 
-pandas.core.indexes.period
-DatetimeIndexOpsMixin6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin",pandas.core.indexes.extension.ExtensionIndex*
-freq;pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.freq"
-2Union[pandas._libs.tslibs.offsets.BaseOffset,None]P
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
-None*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin0:builtins.property`*
-freqstr>pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.freqstr"D
-Union[builtins.str,None]
-builtins.str"builtins.str
-None*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin0:builtins.property`*
-is_all_datesCpandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.is_all_dates"
-
builtins.bool"
builtins.bool*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin0:builtins.property`*
-min:pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.min"
-Any*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
-axis
-Any *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*
-argmin=pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.argmin"
-Any*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
-axis
-Any *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*
-max:pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.max"
-Any*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
-axis
-Any *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*
-argmax=pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.argmax"
-Any*
-self
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*
-axis
-Any *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*
-__rsub__?pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin.__rsub__"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-Ipandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin*~
-;pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin[Any]
-Any"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixinPA
+pandas.core.indexes.period=
 PeriodIndex&pandas.core.indexes.period.PeriodIndex"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin"1pandas.core.indexes.accessors.PeriodIndexFieldOps*
 __new__.pandas.core.indexes.period.PeriodIndex.__new__"
 Any*
@@ -430,12 +72,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 
inferred_type4pandas.core.indexes.period.PeriodIndex.inferred_type"
 builtins.str"builtins.str*Z
 selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`*\
-	get_value0pandas.core.indexes.period.PeriodIndex.get_value*
-self*
-
-series*
-key*
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`*
 get_indexer2pandas.core.indexes.period.PeriodIndex.get_indexer*
 self*
 
@@ -446,11 +83,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 get_indexer_non_unique=pandas.core.indexes.period.PeriodIndex.get_indexer_non_unique*
 self*
 
-target*]
-get_loc.pandas.core.indexes.period.PeriodIndex.get_loc*
-self*
-key*
-	tolerance *T
+target*T
 insert-pandas.core.indexes.period.PeriodIndex.insert*
 self*
 loc*
@@ -468,14 +101,6 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 return_indexers
 
builtins.bool"
builtins.bool **
 sort
-
builtins.bool"
builtins.bool *
-intersection3pandas.core.indexes.period.PeriodIndex.intersection"
-Any*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-other
-Any**
-sort
 
builtins.bool"
builtins.bool *`
 
 difference1pandas.core.indexes.period.PeriodIndex.difference*
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.range.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.range.protobuf
index 61332bfd42..82b55fbfef 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.range.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.range.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.timedeltas.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.timedeltas.protobuf
index 20c8a72deb..46ca7fe434 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.timedeltas.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.indexes.timedeltas.protobuf
@@ -1,6 +1,6 @@
 
-pandas.core.indexes.timedeltasA
-TimedeltaIndex-pandas.core.indexes.timedeltas.TimedeltaIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"6pandas.core.indexes.accessors.TimedeltaIndexProperties*
+pandas.core.indexes.timedeltasT
+TimedeltaIndex-pandas.core.indexes.timedeltas.TimedeltaIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"6pandas.core.indexes.accessors.TimedeltaIndexProperties*
 __new__5pandas.core.indexes.timedeltas.TimedeltaIndex.__new__"
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
@@ -26,23 +26,7 @@ cUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedel
 datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta&
 numpy.timedelta64"numpy.timedelta64 
-builtins.float"builtins.float"typing.Sequence *
-unit
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *
+builtins.float"builtins.float"typing.Sequence *
 freq
 :Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.strP
@@ -55,19 +39,21 @@ cUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedel
 copy
 
builtins.bool"
builtins.bool *(
 name
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 __radd__6pandas.core.indexes.timedeltas.TimedeltaIndex.__radd__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*`^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-[Union[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]T
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+mUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
 __sub__5pandas.core.indexes.timedeltas.TimedeltaIndex.__sub__"
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
-bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self]T
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+uUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
@@ -76,13 +62,23 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*&$
-builtins.complex"builtins.complex*
-__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__"
-2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
-2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*&$
-builtins.complex"builtins.complex*
+builtins.complex"builtins.complex*
+__rtruediv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__rtruediv__"r
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence*
+
__rfloordiv__;pandas.core.indexes.timedeltas.TimedeltaIndex.__rfloordiv__"l
+,pandas.core.indexes.base.Index[builtins.int]
+builtins.int"builtins.int"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence*
 astype4pandas.core.indexes.timedeltas.TimedeltaIndex.astype"
 Any*h
 self^
@@ -90,16 +86,7 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 dtype
 Any**
 copy
-
builtins.bool"
builtins.bool *c
-	get_value7pandas.core.indexes.timedeltas.TimedeltaIndex.get_value*
-self*
-
-series*
-key*d
-get_loc5pandas.core.indexes.timedeltas.TimedeltaIndex.get_loc*
-self*
-key*
-	tolerance *
+
builtins.bool"
builtins.bool *
 searchsorted:pandas.core.indexes.timedeltas.TimedeltaIndex.searchsorted"
 Any*h
 self^
@@ -125,7 +112,7 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 index
 Any *
 name
-Any 2
+Any 2
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__"P
 &pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*`^
@@ -134,16 +121,55 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*`^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__"
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
-bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self]T
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+uUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(0:typing.overloadX
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(0:typing.overloadX2
+
+__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__
+__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__"
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+7Union[builtins.complex,typing.Sequence[builtins.float]]$
+builtins.complex"builtins.complexT
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence0:typing.overloadX
+__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__"r
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence0:typing.overloadX2
+
+__floordiv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__floordiv__
+__floordiv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__floordiv__"
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+7Union[builtins.complex,typing.Sequence[builtins.float]]$
+builtins.complex"builtins.complexT
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence0:typing.overloadX
+__floordiv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__floordiv__"l
+,pandas.core.indexes.base.Index[builtins.int]
+builtins.int"builtins.int"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence0:typing.overloadX
 timedelta_range.pandas.core.indexes.timedeltas.timedelta_range"^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
 start
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.resample.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.resample.protobuf
index a9b74be03b..25156bcc3c 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.resample.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.resample.protobuf
@@ -1,5 +1,5 @@
 
-pandas.core.resample
+pandas.core.resample
 	Resamplerpandas.core.resample.Resampler"'pandas.core.groupby.groupby.BaseGroupBy*
 __getattr__*pandas.core.resample.Resampler.__getattr__"q
 2pandas.core.groupby.generic.SeriesGroupBy[Any,Any]
@@ -8,46 +8,7 @@
 7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*
-builtins.str"builtins.str*
-__iter__'pandas.core.resample.Resampler.__iter__"
-Jtyping.Generator[Tuple[typing.Hashable,pandas._typing.NDFrameT],None,None]
-.Tuple[typing.Hashable,pandas._typing.NDFrameT]"
-typing.Hashable"typing.Hashablet
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame
-None
-None"typing.Generator*
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*
-obj"pandas.core.resample.Resampler.obj"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler0:builtins.property`*
-ax!pandas.core.resample.Resampler.ax"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler0:builtins.property`*
-	transform(pandas.core.resample.Resampler.transform"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*T
-argK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-args
-Any*
-kwargs
-Any*
+builtins.str"builtins.str*
 ffill$pandas.core.resample.Resampler.ffill"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
@@ -80,29 +41,6 @@ Jtyping.Generator[Tuple[typing.Hashable,pandas._typing.NDFrameT],None,None]
 limitD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None *
-fillna%pandas.core.resample.Resampler.fillna"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*
-method
-tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
 None *
 asfreq%pandas.core.resample.Resampler.asfreq"t
 pandas._typing.NDFrameT:
@@ -132,73 +70,7 @@ fill_value
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
 builtins.complex"builtins.complex"pandas._typing.Scalar
-None *
-std"pandas.core.resample.Resampler.std"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*
-var"pandas.core.resample.Resampler.var"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*
-size#pandas.core.resample.Resampler.size"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*
-count$pandas.core.resample.Resampler.count"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*	
-quantile'pandas.core.resample.Resampler.quantile"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*
-q
-Union[builtins.float,builtins.list[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float]] 
-builtins.float"builtins.floatP
-builtins.list[builtins.float] 
-builtins.float"builtins.float"
builtins.list
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayh
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series *
-kwargs
-Any*
+None *
 sum"pandas.core.resample.Resampler.sum"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
@@ -288,8 +160,8 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 args
 Any*
 kwargs
-Any*
-mean#pandas.core.resample.Resampler.mean"t
+Any*
+median%pandas.core.resample.Resampler.median"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
 self
@@ -301,8 +173,8 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 args
 Any*
 kwargs
-Any*
-sem"pandas.core.resample.Resampler.sem"t
+Any*
+mean#pandas.core.resample.Resampler.mean"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
 self
@@ -314,160 +186,93 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 args
 Any*
 kwargs
-Any*
-median%pandas.core.resample.Resampler.median"t
+Any*
+std"pandas.core.resample.Resampler.std"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
 self
 7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
 pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*2
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*(
+ddof
+builtins.int"builtins.int *2
 numeric_only
 
builtins.bool"
builtins.bool *
 args
 Any*
 kwargs
-Any*
-ohlc#pandas.core.resample.Resampler.ohlc":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+Any*
+var"pandas.core.resample.Resampler.var"t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
 self
 7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
 pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*(
+ddof
+builtins.int"builtins.int *2
+numeric_only
+
builtins.bool"
builtins.bool *
 args
 Any*
 kwargs
-Any*
-nunique&pandas.core.resample.Resampler.nunique"t
+Any*
+sem"pandas.core.resample.Resampler.sem"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
 self
 7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
 pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*
-args
-Any*
-kwargs
-Any2+
-pipe#pandas.core.resample.Resampler.pipe
-pipe#pandas.core.resample.Resampler.pipe":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-;pandas.core.resample.Resampler[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas.core.resample.Resampler*
-func
-Union[CallableType[builtins.function],Tuple[CallableType[builtins.function],builtins.str],CallableType[builtins.function],Tuple[CallableType[builtins.function],builtins.str]]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-3Tuple[CallableType[builtins.function],builtins.str]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function
-3Tuple[CallableType[builtins.function],builtins.str]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-pipe#pandas.core.resample.Resampler.pipe"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-;pandas.core.resample.Resampler[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas.core.resample.Resampler*
-func
-ZUnion[CallableType[builtins.function],Tuple[CallableType[builtins.function],builtins.str]]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-3Tuple[CallableType[builtins.function],builtins.str]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-pipe#pandas.core.resample.Resampler.pipe"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
->pandas.core.resample.Resampler[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"pandas.core.resample.Resampler*
-func
-ZUnion[CallableType[builtins.function],Tuple[CallableType[builtins.function],builtins.str]]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-3Tuple[CallableType[builtins.function],builtins.str]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str*
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*(
+ddof
+builtins.int"builtins.int *2
+numeric_only
+
builtins.bool"
builtins.bool *
 args
 Any*
 kwargs
-Any0:typing.overloadX
-pipe#pandas.core.resample.Resampler.pipe"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
->pandas.core.resample.Resampler[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"pandas.core.resample.Resampler*
-func
-ZUnion[CallableType[builtins.function],Tuple[CallableType[builtins.function],builtins.str]]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-3Tuple[CallableType[builtins.function],builtins.str]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str*
+Any*
+ohlc#pandas.core.resample.Resampler.ohlc":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*
 args
 Any*
 kwargs
-Any0:typing.overloadX
-pipe#pandas.core.resample.Resampler.pipe":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
->pandas.core.resample.Resampler[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"pandas.core.resample.Resampler*
-func
-ZUnion[CallableType[builtins.function],Tuple[CallableType[builtins.function],builtins.str]]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-3Tuple[CallableType[builtins.function],builtins.str]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str*
-args
-Any*
+Any*
+size#pandas.core.resample.Resampler.size"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*	
+quantile'pandas.core.resample.Resampler.quantile"t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+self
+7pandas.core.resample.Resampler[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.resample.Resampler*
+q
+Union[builtins.float,builtins.list[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float]] 
+builtins.float"builtins.floatP
+builtins.list[builtins.float] 
+builtins.float"builtins.float"
builtins.list
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayh
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series *
 kwargs
-Any0:typing.overloadX2'
-	aggregate(pandas.core.resample.Resampler.aggregate
-	aggregate(pandas.core.resample.Resampler.aggregate"
-AUnion[pandas.core.series.Series[Any],pandas.core.frame.DataFrame]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series:
+Any2&
+	aggregate(pandas.core.resample.Resampler.aggregate
+	aggregate(pandas.core.resample.Resampler.aggregate":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 self
 ;pandas.core.resample.Resampler[pandas.core.frame.DataFrame]:
@@ -533,8 +338,67 @@ RUnion[CallableType[builtins.function],CallableType[builtins.function],numpy.ufu
 args
 Any*
 kwargs
-Any0:typing.overloadX2=
-interpolate*pandas.core.resample.Resampler.interpolate
+Any0:typing.overloadX2
+	transform(pandas.core.resample.Resampler.transform
+	transform(pandas.core.resample.Resampler.transform"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+>pandas.core.resample.Resampler[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series"pandas.core.resample.Resampler*T
+argK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+args
+Any*
+kwargs
+Any0:typing.overloadX
+	transform(pandas.core.resample.Resampler.transform":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+;pandas.core.resample.Resampler[pandas.core.frame.DataFrame]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas.core.resample.Resampler*T
+argK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+args
+Any*
+kwargs
+Any0:typing.overloadX2A
+interpolate*pandas.core.resample.Resampler.interpolate
 interpolate*pandas.core.resample.Resampler.interpolate"
 None*
 self
@@ -617,14 +481,17 @@ limit_area
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str
-None *x
-downcasth
-!Union[Literal[builtins.str],None]7
+None *
+downcast
+QUnion[Literal[builtins.str],None,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]7
 Literal[builtins.str]	
 builtins.str"builtins.str
-None *
+None
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
 kwargs
-Any0:typing.overloadX
+Any0:typing.overloadX 
 interpolate*pandas.core.resample.Resampler.interpolate"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
@@ -708,20 +575,184 @@ limit_area
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str
-None *x
-downcasth
-!Union[Literal[builtins.str],None]7
+None *
+downcast
+QUnion[Literal[builtins.str],None,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]7
 Literal[builtins.str]	
 builtins.str"builtins.str
-None *
+None
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+kwargs
+Any0:typing.overloadX2
+nunique&pandas.core.resample.Resampler.nunique
+nunique&pandas.core.resample.Resampler.nunique"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+>pandas.core.resample.Resampler[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series"pandas.core.resample.Resampler*
+args
+Any*
 kwargs
-Any0:typing.overloadXPr
+Any0:typing.overloadX
+nunique&pandas.core.resample.Resampler.nunique":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+;pandas.core.resample.Resampler[pandas.core.frame.DataFrame]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas.core.resample.Resampler*
+args
+Any*
+kwargs
+Any0:typing.overloadX2
+count$pandas.core.resample.Resampler.count
+count$pandas.core.resample.Resampler.count"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+>pandas.core.resample.Resampler[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series"pandas.core.resample.Resampler0:typing.overloadX
+count$pandas.core.resample.Resampler.count":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+;pandas.core.resample.Resampler[pandas.core.frame.DataFrame]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas.core.resample.Resampler0:typing.overloadXPr{
+grouper&pandas.core.resample.Resampler.grouperH
+"pandas.core.groupby.ops.BinGrouper""pandas.core.groupby.ops.BinGrouperr
+binner%pandas.core.resample.Resampler.binner
+Union[pandas.core.indexes.datetimes.DatetimeIndex,pandas.core.indexes.timedeltas.TimedeltaIndex,pandas.core.indexes.period.PeriodIndex]Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndexr
+
+exclusions)pandas.core.resample.Resampler.exclusions]
+#builtins.frozenset[typing.Hashable]"
+typing.Hashable"typing.Hashable"builtins.frozensetrw
+ax!pandas.core.resample.Resampler.axN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Indexr
 agg"pandas.core.resample.Resampler.agg^
 CallableType[builtins.function]&
 builtins.function"builtins.function"builtins.functionr
 apply$pandas.core.resample.Resampler.apply^
 CallableType[builtins.function]&
-builtins.function"builtins.function"builtins.function*
+builtins.function"builtins.function"builtins.function
+
_GroupByMixin"pandas.core.resample._GroupByMixin"pandas.core.resample.Resampler*
+__getitem__.pandas.core.resample._GroupByMixin.__getitem__"
+'pandas.core.resample._GroupByMixin.Self
+;pandas.core.resample._GroupByMixin[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame""pandas.core.resample._GroupByMixin""pandas.core.resample._GroupByMixin(*
+'pandas.core.resample._GroupByMixin.Self
+;pandas.core.resample._GroupByMixin[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame""pandas.core.resample._GroupByMixin""pandas.core.resample._GroupByMixin(*	
+AnyPr
+key&pandas.core.resample._GroupByMixin.key
+4Union[builtins.str,builtins.list[builtins.str],None]
+builtins.str"builtins.strJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list
+Noneg
+DatetimeIndexResampler+pandas.core.resample.DatetimeIndexResampler"pandas.core.resample.ResamplerP
+DatetimeIndexResamplerGroupby2pandas.core.resample.DatetimeIndexResamplerGroupby""pandas.core.resample._GroupByMixin"+pandas.core.resample.DatetimeIndexResampler*
+__getattr__>pandas.core.resample.DatetimeIndexResamplerGroupby.__getattr__"
+7pandas.core.resample.DatetimeIndexResamplerGroupby.Self
+Kpandas.core.resample.DatetimeIndexResamplerGroupby[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"2pandas.core.resample.DatetimeIndexResamplerGroupby"2pandas.core.resample.DatetimeIndexResamplerGroupby(*
+7pandas.core.resample.DatetimeIndexResamplerGroupby.Self
+Kpandas.core.resample.DatetimeIndexResamplerGroupby[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"2pandas.core.resample.DatetimeIndexResamplerGroupby"2pandas.core.resample.DatetimeIndexResamplerGroupby(*
+builtins.str"builtins.strPp
+PeriodIndexResampler)pandas.core.resample.PeriodIndexResampler"+pandas.core.resample.DatetimeIndexResamplerP
+PeriodIndexResamplerGroupby0pandas.core.resample.PeriodIndexResamplerGroupby""pandas.core.resample._GroupByMixin")pandas.core.resample.PeriodIndexResampler*
+__getattr__
-__getitem__0pandas.core.series._LocIndexerSeries.__getitem__"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None0:typing.overloadXPц
+_LocIndexerSeries$pandas.core.series._LocIndexerSeries" pandas.core.indexing._LocIndexer2
+__getitem__0pandas.core.series._LocIndexerSeries.__getitem__7
+__getitem__0pandas.core.series._LocIndexerSeries.__getitem__"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -422,17 +397,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -459,14 +431,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"$pandas.core.series._LocIndexerSeries*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"$pandas.core.series._LocIndexerSeries*
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],builtins.tuple[Unknown]]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
@@ -486,11 +455,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
 builtins.complex"builtins.complex"pandas._typing.Scalar+
-builtins.tuple[Unknown]"builtins.tuple0:typing.overloadXe
-__getitem__0pandas.core.series._LocIndexerSeries.__getitem__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.tuple[Unknown]"builtins.tuple0:typing.overloadX^
+__getitem__0pandas.core.series._LocIndexerSeries.__getitem__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -517,17 +486,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -554,15 +520,12 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"$pandas.core.series._LocIndexerSeries*66
-Union[TypeAlias[Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]],pandas.core.indexes.base.Index[Any],typing.Sequence[builtins.float],builtins.list[builtins.str],builtins.slice,TypeAlias[builtins.tuple[Union[pandas.core.indexes.base.Index[Any],Unknown,TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],builtins.list[pandas._typing.ScalarT],builtins.slice,builtins.tuple[Unknown]]]],CallableType[builtins.function]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"$pandas.core.series._LocIndexerSeries*77
+Union[TypeAlias[Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]],pandas.core.indexes.base.Index[Any],typing.Sequence[builtins.float],builtins.list[builtins.str],builtins.slice,TypeAlias[builtins.tuple[Union[pandas.core.indexes.base.Index[Any],Unknown,TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],builtins.list[pandas._typing.ScalarT],builtins.slice,builtins.tuple[Unknown]]]],typing.Sequence[Unknown],CallableType[builtins.function]]
 TypeAlias[Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]]
 Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]e
 (pandas.core.series.Series[builtins.bool]
@@ -626,15 +589,16 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
 builtins.complex"builtins.complex"
builtins.list 
 builtins.slice"builtins.slice+
-builtins.tuple[Unknown]"builtins.tuple"builtins.tuple"%pandas.core.indexing._IndexSliceTupleK
+builtins.tuple[Unknown]"builtins.tuple"builtins.tuple"%pandas.core.indexing._IndexSliceTuple-
+typing.Sequence[Unknown]"typing.SequenceK
 CallableType[builtins.function]&
-builtins.function"builtins.function0:typing.overloadX2
-__setitem__0pandas.core.series._LocIndexerSeries.__setitem__S
+builtins.function"builtins.function0:typing.overloadX2
+__setitem__0pandas.core.series._LocIndexerSeries.__setitem__I
 __setitem__0pandas.core.series._LocIndexerSeries.__setitem__"
-None*
-7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -661,14 +625,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"$pandas.core.series._LocIndexerSeries*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"$pandas.core.series._LocIndexerSeries*
 Union[pandas.core.indexes.base.Index[Any],TypeAlias[Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]]]N
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.Index
@@ -684,10 +645,10 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boolM
 builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.list"pandas._typing.MaskType*11
-Union[pandas._typing.S1,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.series.Series[pandas._typing.S1],None]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"
builtins.list"pandas._typing.MaskType*))
+Union[pandas._typing.S1,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.series.Series[pandas._typing.S1],None]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -714,23 +675,20 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -757,20 +715,17 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None0:typing.overloadX.
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None0:typing.overloadX'
 __setitem__0pandas.core.series._LocIndexerSeries.__setitem__"
-None*
-7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -797,18 +752,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"$pandas.core.series._LocIndexerSeries*
-builtins.str"builtins.str*
-Union[pandas._typing.S1,None]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"$pandas.core.series._LocIndexerSeries*
+builtins.str"builtins.str*
+Union[pandas._typing.S1,None]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -835,20 +787,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-None0:typing.overloadXL
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+None0:typing.overloadX~
 __setitem__0pandas.core.series._LocIndexerSeries.__setitem__"
-None*
-7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -875,26 +824,97 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"$pandas.core.series._LocIndexerSeries*@@
+Union[TypeAlias[Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]],TypeAlias[Union[builtins.str,numpy.str_]],TypeAlias[builtins.tuple[Union[pandas.core.indexes.base.Index[Any],Unknown,TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],builtins.list[pandas._typing.ScalarT],builtins.slice,builtins.tuple[Unknown]]]],builtins.list[pandas._typing.ScalarT]]
+TypeAlias[Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]]
+Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.list"pandas._typing.MaskType
+)TypeAlias[Union[builtins.str,numpy.str_]]Z
+Union[builtins.str,numpy.str_]
+builtins.str"builtins.str
+
+numpy.str_"
+numpy.str_"pandas._typing.StrLike$
+TypeAlias[builtins.tuple[Union[pandas.core.indexes.base.Index[Any],Unknown,TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],builtins.list[pandas._typing.ScalarT],builtins.slice,builtins.tuple[Unknown]]]]!
+builtins.tuple[Union[pandas.core.indexes.base.Index[Any],Unknown,TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],builtins.list[pandas._typing.ScalarT],builtins.slice,builtins.tuple[Unknown]]]
+Union[pandas.core.indexes.base.Index[Any],Unknown,TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],builtins.list[pandas._typing.ScalarT],builtins.slice,builtins.tuple[Unknown]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"$pandas.core.series._LocIndexerSeries*
-nUnion[builtins.list[builtins.int],builtins.list[builtins.str],builtins.list[Union[builtins.str,builtins.int]]]J
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-/builtins.list[Union[builtins.str,builtins.int]]`
- Union[builtins.str,builtins.int]
-builtins.str"builtins.str
-builtins.int"builtins.int"
builtins.list*11
-Union[pandas._typing.S1,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.series.Series[pandas._typing.S1],None]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+%builtins.list[pandas._typing.ScalarT]
+pandas._typing.ScalarT
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"
builtins.list 
+builtins.slice"builtins.slice+
+builtins.tuple[Unknown]"builtins.tuple"builtins.tuple"%pandas.core.indexing._IndexSliceTuple
+%builtins.list[pandas._typing.ScalarT]
+pandas._typing.ScalarT
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"
builtins.list*))
+Union[pandas._typing.S1,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.series.Series[pandas._typing.S1],None]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -921,23 +941,20 @@ nUnion[builtins.list[builtins.int],builtins.list[builtins.str],builtins.list[Uni
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -964,22 +981,19 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None0:typing.overloadXPt
-Seriespandas.core.series.Series"pandas.core.base.IndexOpsMixin"pandas.core.generic.NDFrame*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None0:typing.overloadXPv
+Seriespandas.core.series.Series"pandas.core.base.IndexOpsMixin"pandas.core.generic.NDFrame*
 hasnans!pandas.core.series.Series.hasnans"
-
builtins.bool"
builtins.bool*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1006,21 +1020,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*?
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*]
 divpandas.core.series.Series.div"h
 )pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1047,19 +1058,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -1070,16 +1078,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1106,20 +1108,85 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
 None *\
 
 fill_valueJ
@@ -1132,11 +1199,11 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Z
-rdivpandas.core.series.Series.rdiv"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rdivpandas.core.series.Series.rdiv"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1163,18 +1230,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1201,19 +1265,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1240,14 +1301,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -1284,17 +1342,17 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
+builtins.int"builtins.int"pandas._typing.AxisIndex *
 dtypepandas.core.series.Series.dtype"
 STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
 HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 numpy.dtype[numpy.generic]
 
numpy.generic"
numpy.generic"numpy.dtypeP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1321,24 +1379,21 @@ HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
 dtypes pandas.core.series.Series.dtypes"
 STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
 HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 numpy.dtype[numpy.generic]
 
numpy.generic"
numpy.generic"numpy.dtypeP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1365,25 +1420,22 @@ HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
 values pandas.core.series.Series.values"
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"pandas._typing.ArrayLike*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1410,20 +1462,17 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
 arraypandas.core.series.Series.array"P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1450,22 +1499,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
 ravelpandas.core.series.Series.ravel"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1492,21 +1538,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*)
 order
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 __len__!pandas.core.series.Series.__len__"
-builtins.int"builtins.int*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1533,18 +1576,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*.
-viewpandas.core.series.Series.view"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*'
+viewpandas.core.series.Series.view"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1571,18 +1611,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1609,22 +1646,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 dtype
-Any *
+Any *
 __array_ufunc__)pandas.core.series.Series.__array_ufunc__"
-Any*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1651,14 +1685,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*V
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*V
 ufuncK
 CallableType[builtins.function]&
 builtins.function"builtins.function*(
@@ -1667,15 +1698,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 inputs
 Any*
 kwargs
-Any*
+Any*
 	__array__#pandas.core.series.Series.__array__"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1702,23 +1733,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 dtype
-Any *
+Any *
 axespandas.core.series.Series.axes",
 builtins.list[Any]
-Any"
builtins.list*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
builtins.list*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1745,18 +1773,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*1
-takepandas.core.series.Series.take"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*)
+takepandas.core.series.Series.take"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1783,18 +1808,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1821,14 +1843,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*=
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*=
 indices0
 typing.Sequence[Any]
 Any"typing.Sequence*
@@ -1838,16 +1857,12 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *V
-is_copyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
+builtins.int"builtins.int"pandas._typing.AxisIndex *
 kwargs
-Any*-
-__getattr__%pandas.core.series.Series.__getattr__"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*&
+__getattr__%pandas.core.series.Series.__getattr__"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1874,17 +1889,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1911,20 +1923,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-builtins.str"builtins.str*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+builtins.str"builtins.str*
 __setitem__%pandas.core.series.Series.__setitem__"
-None*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1951,20 +1960,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*	
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*	
 Any*	
-Any*2
-repeat pandas.core.series.Series.repeat"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*+
+repeat pandas.core.series.Series.repeat"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1991,18 +1997,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2029,14 +2032,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 repeats
 /Union[builtins.int,builtins.list[builtins.int]]
 builtins.int"builtins.intJ
@@ -2050,13 +2050,13 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *
+None *
 	to_xarray#pandas.core.series.Series.to_xarray"
-Any*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2083,20 +2083,17 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*.
-itemspandas.core.series.Series.items"
-9typing.Iterable[Tuple[typing.Hashable,pandas._typing.S1]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*'
+itemspandas.core.series.Series.items"
+9typing.Iterable[Tuple[typing.Hashable,pandas._typing.S1]]
 (Tuple[typing.Hashable,pandas._typing.S1]"
-typing.Hashable"typing.Hashable
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+typing.Hashable"typing.Hashable
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2123,18 +2120,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Iterable*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterable*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2161,21 +2155,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 keyspandas.core.series.Series.keys",
 builtins.list[Any]
-Any"
builtins.list*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
builtins.list*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2202,20 +2193,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 to_frame"pandas.core.series.Series.to_frame":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2242,22 +2230,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*Y
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*Y
 nameM
 Union[builtins.object,None]"
 builtins.object"builtins.object
-None *.
-modepandas.core.series.Series.mode"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *'
+modepandas.core.series.Series.mode"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2284,18 +2269,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2322,24 +2304,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 dropna
-Any *
+Any *
 unique pandas.core.series.Series.unique"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2366,22 +2345,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 
 duplicated$pandas.core.series.Series.duplicated"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2408,14 +2384,11 @@ duplicated$pandas.core.series.Series.duplicated"e
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 keep
 [Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.bool]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
@@ -2425,15 +2398,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str"pandas._typing.NaPosition:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 idxmax pandas.core.series.Series.idxmax"`
  Union[builtins.int,builtins.str]
 builtins.int"builtins.int
-builtins.str"builtins.str*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2460,14 +2433,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
@@ -2480,15 +2450,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 args
 Any*
 kwargs
-Any*
+Any*
 idxmin pandas.core.series.Series.idxmin"`
  Union[builtins.int,builtins.str]
 builtins.int"builtins.int
-builtins.str"builtins.str*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2515,14 +2485,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
@@ -2535,11 +2502,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 args
 Any*
 kwargs
-Any*.
-roundpandas.core.series.Series.round"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*'
+roundpandas.core.series.Series.round"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2566,18 +2533,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2604,26 +2568,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*,
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*,
 decimals
 builtins.int"builtins.int *
 args
 Any*
 kwargs
-Any*0
+Any*)
 corrpandas.core.series.Series.corr" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2650,18 +2611,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2688,14 +2646,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 method
 HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
@@ -2705,13 +2660,13 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str */
 min_periods
-builtins.int"builtins.int */
+builtins.int"builtins.int *(
 covpandas.core.series.Series.cov" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2738,18 +2693,15 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2776,104 +2728,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*W
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*W
 min_periodsD
 Union[builtins.int,None]
 builtins.int"builtins.int
 None *(
 ddof
-builtins.int"builtins.int *.
-diffpandas.core.series.Series.diff"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int *
+builtins.int"builtins.int *
 autocorr"pandas.core.series.Series.autocorr" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2900,23 +2771,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*'
 lag
 builtins.int"builtins.int *6
 
 __matmul__$pandas.core.series.Series.__matmul__***8
-__rmatmul__%pandas.core.series.Series.__rmatmul__***U
-combine!pandas.core.series.Series.combine"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+__rmatmul__%pandas.core.series.Series.__rmatmul__***K
+combine!pandas.core.series.Series.combine"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2943,18 +2811,15 @@ __matmul__$pandas.core.series.Series.__matmul__***8
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -2981,18 +2846,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3019,14 +2881,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*U
 funcK
 CallableType[builtins.function]&
 builtins.function"builtins.function*
@@ -3051,11 +2910,11 @@ fill_value
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
 builtins.complex"builtins.complex"pandas._typing.Scalar
-None *E
-
combine_first'pandas.core.series.Series.combine_first"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *:
+
combine_first'pandas.core.series.Series.combine_first"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3082,18 +2941,15 @@ fill_value
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3120,18 +2976,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3158,20 +3011,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*N
 update pandas.core.series.Series.update"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3198,19 +3048,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*E
-otherE
-Union[pandas.core.series.Series[pandas._typing.S1],typing.Sequence[pandas._typing.S1],typing.Mapping[builtins.int,pandas._typing.S1]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*;
+other:
+Union[pandas.core.series.Series[pandas._typing.S1],typing.Sequence[pandas._typing.S1],typing.Mapping[builtins.int,pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3237,17 +3084,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-"typing.Sequence[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3274,18 +3118,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Sequence
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
 .typing.Mapping[builtins.int,pandas._typing.S1]
-builtins.int"builtins.int
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3312,21 +3153,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Mapping*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Mapping*
 argsort!pandas.core.series.Series.argsort"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3353,14 +3191,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
@@ -3380,11 +3215,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str"pandas._typing.SortKind *
 order
-None *1
-nlargest"pandas.core.series.Series.nlargest"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None **
+nlargest"pandas.core.series.Series.nlargest"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3411,18 +3246,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3449,14 +3281,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*%
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
 n
 builtins.int"builtins.int *
 keep
@@ -3468,11 +3297,11 @@ ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[bui
 Literal[builtins.str]	
 builtins.str"builtins.str"pandas._typing.NaPosition7
 Literal[builtins.str]	
-builtins.str"builtins.str *1
-	nsmallest#pandas.core.series.Series.nsmallest"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str **
+	nsmallest#pandas.core.series.Series.nsmallest"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3499,18 +3328,15 @@ ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[bui
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3537,14 +3363,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*%
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
 n
 builtins.int"builtins.int *
 keep
@@ -3556,11 +3379,11 @@ ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[bui
 Literal[builtins.str]	
 builtins.str"builtins.str"pandas._typing.NaPosition7
 Literal[builtins.str]	
-builtins.str"builtins.str *1
-	swaplevel#pandas.core.series.Series.swaplevel"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str **
+	swaplevel#pandas.core.series.Series.swaplevel"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3587,18 +3410,15 @@ ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[bui
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3625,14 +3445,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 i
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
@@ -3644,11 +3461,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 typing.Hashable"typing.Hashable
 builtins.int"builtins.int"pandas._typing.Level **
 copy
-
builtins.bool"
builtins.bool *.
-reorder_levels(pandas.core.series.Series.reorder_levels"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool *'
+reorder_levels(pandas.core.series.Series.reorder_levels"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3675,18 +3492,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3713,21 +3527,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*7
 order,
 builtins.list[Any]
-Any"
builtins.list*.
-explode!pandas.core.series.Series.explode"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
builtins.list*'
+explode!pandas.core.series.Series.explode"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3754,18 +3565,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3792,20 +3600,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 unstack!pandas.core.series.Series.unstack":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3832,14 +3637,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
@@ -3853,100 +3655,17 @@ fill_value
 builtins.dict[Any,Any]
 Any
 Any"
builtins.dict
-None */
-mappandas.core.series.Series.map"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-arg
-Any*y
-	na_actionh
-!Union[Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None *3
+None *0
 alignpandas.core.series.Series.align"
 DTuple[pandas.core.series.Series[Any],pandas.core.series.Series[Any]]D
 pandas.core.series.Series[Any]
 Any"pandas.core.series.SeriesD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -3973,14 +3692,11 @@ DTuple[pandas.core.series.Series[Any],pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 other
 AUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any]]:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
@@ -4058,14 +3774,12 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *6
-reindex_like&pandas.core.series.Series.reindex_like"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *C
+reindex_like&pandas.core.series.Series.reindex_like"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4092,18 +3806,16 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4130,14 +3842,46 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+other
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 method
 Union[builtins.str,TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],None]
 builtins.str"builtins.str
@@ -4163,11 +3907,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 	toleranceJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *1
-shiftpandas.core.series.Series.shift"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None **
+shiftpandas.core.series.Series.shift"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4194,18 +3938,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4232,14 +3973,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*+
 periods
 builtins.int"builtins.int *
 freq
@@ -4255,13 +3993,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fill_valueM
 Union[builtins.object,None]"
 builtins.object"builtins.object
-None *
+None *
 memory_usage&pandas.core.series.Series.memory_usage"
-builtins.int"builtins.int*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4288,25 +4026,22 @@ fill_valueM
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*+
 index
 
builtins.bool"
builtins.bool **
 deep
-
builtins.bool"
builtins.bool *0
+
builtins.bool"
builtins.bool *)
 isinpandas.core.series.Series.isin"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4333,21 +4068,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-values
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+values
 _Union[typing.Iterable[Any],pandas.core.series.Series[pandas._typing.S1],builtins.dict[Any,Any]]0
 typing.Iterable[Any]
-Any"typing.Iterable
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"typing.Iterable
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4374,24 +4106,21 @@ _Union[typing.Iterable[Any],pandas.core.series.Series[pandas._typing.S1],builtin
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series9
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series9
 builtins.dict[Any,Any]
 Any
-Any"
builtins.dict*E
+Any"
builtins.dict*A
 between!pandas.core.series.Series.between"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4418,14 +4147,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 left
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -4497,14 +4223,14 @@ uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 isnapandas.core.series.Series.isna"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4531,21 +4257,18 @@ uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 isnull pandas.core.series.Series.isnull"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4572,21 +4295,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 notnapandas.core.series.Series.notna"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4613,21 +4333,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 notnull!pandas.core.series.Series.notnull"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4654,18 +4371,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*2
-to_timestamp&pandas.core.series.Series.to_timestamp"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*+
+to_timestamp&pandas.core.series.Series.to_timestamp"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4692,18 +4406,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4730,14 +4441,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 freq
 Any *
 how
@@ -4752,13 +4460,13 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str""pandas._typing.TimestampConvention **
 copy
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 	to_period#pandas.core.series.Series.to_period":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4785,29 +4493,28 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*P
 freqD
 Union[builtins.str,None]
 builtins.str"builtins.str
 None **
 copy
-
builtins.bool"
builtins.bool *
-strpandas.core.series.Series.str"
-]pandas.core.strings.StringMethods[pandas.core.series.Series[Any],pandas.core.frame.DataFrame]D
+
builtins.bool"
builtins.bool *
+strpandas.core.series.Series.str"
+pandas.core.strings.StringMethods[pandas.core.series.Series[Any],pandas.core.frame.DataFrame,pandas.core.series.Series[builtins.bool]]D
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"!pandas.core.strings.StringMethods*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFramee
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series"!pandas.core.strings.StringMethods*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -4834,20 +4541,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
 dtpandas.core.series.Series.dt"|
-
+interpolate%pandas.core.series.Series.interpolate"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6385,18 +6071,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6423,14 +6106,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 method
 TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
 Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
@@ -6508,8 +6188,8 @@ limit_area
 builtins.str"builtins.str
 None *
 kwargs
-Any*P
-asofpandas.core.series.Series.asof"&
+Any*I
+asofpandas.core.series.Series.asof"#
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
@@ -6528,10 +6208,10 @@ limit_area
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6558,18 +6238,15 @@ limit_area
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6596,14 +6273,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 where
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],typing.Sequence[Unknown]]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -6630,11 +6304,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.str"builtins.strN
 typing.Sequence[builtins.str]
 builtins.str"builtins.str"typing.Sequence
-None *;
-clippandas.core.series.Series.clip"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *4
+clippandas.core.series.Series.clip"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6661,18 +6335,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6699,14 +6370,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 lower
 Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.float,None]
 kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
@@ -6745,11 +6413,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 inplace
 
builtins.bool"
builtins.bool *
 kwargs
-Any*E
-asfreq pandas.core.series.Series.asfreq"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*=
+asfreq pandas.core.series.Series.asfreq"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6776,18 +6444,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6814,14 +6479,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 freq
 Any*
 method
@@ -6867,11 +6529,11 @@ fill_value
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
 builtins.complex"builtins.complex"pandas._typing.Scalar
-None *2
-at_time!pandas.core.series.Series.at_time"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *+
+at_time!pandas.core.series.Series.at_time"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6898,18 +6560,15 @@ fill_value
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6936,14 +6595,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*m
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*m
 timec
 !Union[builtins.str,datetime.time]
 builtins.str"builtins.str
@@ -6958,11 +6614,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *2
-between_time&pandas.core.series.Series.between_time"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *+
+between_time&pandas.core.series.Series.between_time"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -6989,18 +6645,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7027,14 +6680,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*s
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*s
 
 start_timec
 !Union[builtins.str,datetime.time]
@@ -7052,15 +6702,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None **
-resample"pandas.core.series.Series.resample"
->pandas.core.resample.Resampler[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"pandas.core.resample.Resampler*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *'
+firstpandas.core.series.Series.first"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7087,130 +6733,20 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-rule
-Any*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *R
-closedD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *Q
-labelD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *
-
-convention
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str""pandas._typing.TimestampConvention *
-kind
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None *
-loffset
-Any *(
-base
-builtins.int"builtins.int *N
-onD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-origin
-Union[pandas._libs.tslibs.timestamps.Timestamp,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *
-offset
-AUnion[pandas._libs.tslibs.timedeltas.Timedelta,builtins.str,None]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
-builtins.str"builtins.str
-None *.
-firstpandas.core.series.Series.first"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.float$
 builtins.complex"builtins.complex	
@@ -7232,20 +6768,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 offset
-Any*.
-lastpandas.core.series.Series.last"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*'
+lastpandas.core.series.Series.last"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7272,18 +6805,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7310,23 +6840,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 offset
-Any* 
-rankpandas.core.series.Series.rank"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+rankpandas.core.series.Series.rank"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7353,14 +6880,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
@@ -7393,11 +6917,11 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 	ascending
 
builtins.bool"
builtins.bool *)
 pct
-
builtins.bool"
builtins.bool *N
-wherepandas.core.series.Series.where"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool *C
+wherepandas.core.series.Series.where"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7424,18 +6948,15 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7462,19 +6983,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-cond
-Union[pandas.core.series.Series[pandas._typing.S1],pandas.core.series.Series[builtins.bool],numpy.ndarray[Any,Any],CallableType[builtins.function],CallableType[builtins.function]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+cond
+Union[pandas.core.series.Series[pandas._typing.S1],pandas.core.series.Series[builtins.bool],numpy.ndarray[Any,Any],CallableType[builtins.function],CallableType[builtins.function]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7501,14 +7019,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Seriese
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Seriese
 (pandas.core.series.Series[builtins.bool]
 
builtins.bool"
builtins.bool"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
@@ -7537,13 +7052,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
 builtins.int"builtins.int"pandas._typing.Level
-None *.
-try_cast
-
builtins.bool"
builtins.bool *e
-maskpandas.core.series.Series.mask"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *i
+maskpandas.core.series.Series.mask"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7570,18 +7083,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7608,29 +7118,57 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+cond
+Union[pandas.core.series.Series[pandas._typing.S1],pandas.core.series.Series[builtins.bool],numpy.ndarray[Any,Any],CallableType[builtins.function],CallableType[builtins.function]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-cond
-TypeAlias[Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]]
-Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]e
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Seriese
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.list"pandas._typing.MaskType*)
-other)
+
builtins.bool"
builtins.bool"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayK
+CallableType[builtins.function]&
+builtins.function"builtins.functionK
+CallableType[builtins.function]&
+builtins.function"builtins.function*%
+other%
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,CallableType[builtins.function],pandas._libs.missing.NAType,None]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
@@ -7649,10 +7187,10 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7679,14 +7217,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrameK
 CallableType[builtins.function]&
 builtins.function"builtins.function:
@@ -7709,13 +7244,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
 builtins.int"builtins.int"pandas._typing.Level
-None *.
-try_cast
-
builtins.bool"
builtins.bool *0
-slice_shift%pandas.core.series.Series.slice_shift"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *6
+	case_when#pandas.core.series.Series.case_when"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7742,18 +7278,57 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*"
+caselist"
+builtins.list[Tuple[Union[typing.Sequence[builtins.bool],pandas.core.series.Series[builtins.bool],CallableType[builtins.function]],Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],CallableType[builtins.function]]]]
+Tuple[Union[typing.Sequence[builtins.bool],pandas.core.series.Series[builtins.bool],CallableType[builtins.function]],Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],CallableType[builtins.function]]]
+nUnion[typing.Sequence[builtins.bool],pandas.core.series.Series[builtins.bool],CallableType[builtins.function]]Q
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequencee
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.SeriesK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],CallableType[builtins.function]]
+TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
+uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
+typing.Sequence[Any]
+Any"typing.Sequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.ScalarK
+CallableType[builtins.function]&
+builtins.function"builtins.function"
builtins.list*,
+truncate"pandas.core.series.Series.truncate"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7780,27 +7355,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *0
-tshift pandas.core.series.Series.tshift"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7827,18 +7390,39 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+before
+3Union[datetime.date,builtins.str,builtins.int,None]
+
datetime.date"
datetime.date
+builtins.str"builtins.str
+builtins.int"builtins.int
+None *
+after
+3Union[datetime.date,builtins.str,builtins.int,None]
+
datetime.date"
datetime.date
+builtins.str"builtins.str
+builtins.int"builtins.int
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None **
+copy
+
builtins.bool"
builtins.bool *+
+
+tz_convert$pandas.core.series.Series.tz_convert"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7865,29 +7449,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int *
-freq
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *4
-truncate"pandas.core.series.Series.truncate"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -7914,152 +7484,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-before
-3Union[datetime.date,builtins.str,builtins.int,None]
-
datetime.date"
datetime.date
-builtins.str"builtins.str
-builtins.int"builtins.int
-None *
-after
-3Union[datetime.date,builtins.str,builtins.int,None]
-
datetime.date"
datetime.date
-builtins.str"builtins.str
-builtins.int"builtins.int
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None **
-copy
-
builtins.bool"
builtins.bool *2
-
-tz_convert$pandas.core.series.Series.tz_convert"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 tz
 Any*
 axis
@@ -8077,11 +7506,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.int"builtins.int"pandas._typing.Level
 None **
 copy
-
builtins.bool"
builtins.bool *3
-tz_localize%pandas.core.series.Series.tz_localize"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool *,
+tz_localize%pandas.core.series.Series.tz_localize"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8108,18 +7537,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8146,14 +7572,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 tz
 Any*
 axis
@@ -8175,11 +7598,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 	ambiguous
 Any */
 nonexistent
-builtins.str"builtins.str *.
-abspandas.core.series.Series.abs"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str *&
+abspandas.core.series.Series.abs"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8206,18 +7629,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8244,18 +7664,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*u
-describe"pandas.core.series.Series.describe"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*c
+describe"pandas.core.series.Series.describe"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8282,18 +7699,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8320,26 +7734,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 percentiles
 )Union[builtins.list[builtins.float],None]P
 builtins.list[builtins.float] 
 builtins.float"builtins.float"
builtins.list
-None *
-include
+None *
+include
 BUnion[Literal[builtins.str],builtins.list[pandas._typing.S1],None]7
 Literal[builtins.str]	
-builtins.str"builtins.str
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8366,19 +7777,16 @@ BUnion[Literal[builtins.str],builtins.list[pandas._typing.S1],None]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-None *-
-exclude-
->Union[pandas._typing.S1,builtins.list[pandas._typing.S1],None]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+None *&
+exclude&
+>Union[pandas._typing.S1,builtins.list[pandas._typing.S1],None]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8405,17 +7813,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8442,24 +7847,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-None *b
-datetime_is_numericG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None */
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+None *(
 
-pct_change$pandas.core.series.Series.pct_change"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+pct_change$pandas.core.series.Series.pct_change"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8486,18 +7884,15 @@ pct_change$pandas.core.series.Series.pct_change"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8524,14 +7919,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*+
 periods
 builtins.int"builtins.int */
 fill_method
@@ -8543,7 +7935,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 freq
 Any *
 kwargs
-Any*$
+Any*!
 first_valid_index+pandas.core.series.Series.first_valid_index"
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
@@ -8562,11 +7954,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8593,14 +7985,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*!
 last_valid_index*pandas.core.series.Series.last_valid_index"
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
@@ -8619,11 +8008,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8650,21 +8039,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-value_counts&pandas.core.series.Series.value_counts"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*'
+	transpose#pandas.core.series.Series.transpose"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8691,30 +8074,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*/
-	normalize
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool */
-	ascending
-
builtins.bool"
builtins.bool *P
-binsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *,
-dropna
-
builtins.bool"
builtins.bool *.
-	transpose#pandas.core.series.Series.transpose"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8741,18 +8109,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+args
+Any*
+kwargs
+Any*(
+Tpandas.core.series.Series.T"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8779,22 +8149,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-args
-Any*
-kwargs
-Any*.
-Tpandas.core.series.Series.T"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8821,18 +8185,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(0:builtins.property`*k
+__div__!pandas.core.series.Series.__div__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8859,18 +8220,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*P
-__div__!pandas.core.series.Series.__div__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8897,18 +8255,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8935,39 +8305,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -8994,20 +8339,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-__eq__ pandas.core.series.Series.__eq__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9034,21 +8373,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$"
-builtins.object"builtins.object*:
-__floordiv__&pandas.core.series.Series.__floordiv__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+__eq__ pandas.core.series.Series.__eq__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9075,38 +8410,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*$"
+builtins.object"builtins.object*X
+__floordiv__&pandas.core.series.Series.__floordiv__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9133,20 +8448,29 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*Q
-__ge__ pandas.core.series.Series.__ge__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9173,17 +8497,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9210,36 +8531,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9266,22 +8565,17 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*Q
-__gt__ pandas.core.series.Series.__gt__"e
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*l
+__ge__ pandas.core.series.Series.__ge__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9308,17 +8602,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*WW
+Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta,datetime.date]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9345,16 +8636,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -9365,16 +8653,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9401,22 +8683,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*Q
-__le__ pandas.core.series.Series.__le__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9443,17 +8717,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9480,36 +8751,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta
+
datetime.date"
datetime.date*l
+__gt__ pandas.core.series.Series.__gt__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9536,22 +8791,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*Q
-__lt__ pandas.core.series.Series.__lt__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*WW
+Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta,datetime.date]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9578,17 +8825,27 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9615,36 +8872,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9671,20 +8906,54 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*P
-__mod__!pandas.core.series.Series.__mod__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta
+
datetime.date"
datetime.date*l
+__le__ pandas.core.series.Series.__le__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9711,17 +8980,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*WW
+Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta,datetime.date]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9748,18 +9014,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -9770,16 +9031,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9806,20 +9061,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-__ne__ pandas.core.series.Series.__ne__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9846,19 +9095,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$"
-builtins.object"builtins.object*P
-__pow__!pandas.core.series.Series.__pow__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9885,17 +9129,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta
+
datetime.date"
datetime.date*l
+__lt__ pandas.core.series.Series.__lt__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9922,38 +9169,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*WW
+Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta,datetime.date]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -9980,18 +9203,27 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__radd__"pandas.core.series.Series.__radd__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10018,17 +9250,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10055,39 +9284,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,builtins.str,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-builtins.str"builtins.str
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10114,18 +9318,18 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rdiv__"pandas.core.series.Series.__rdiv__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta
+
datetime.date"
datetime.date*k
+__mod__!pandas.core.series.Series.__mod__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10152,17 +9356,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10189,18 +9390,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -10211,16 +9409,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10247,18 +9439,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rdivmod__%pandas.core.series.Series.__rdivmod__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10285,18 +9473,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10323,39 +9507,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+__ne__ pandas.core.series.Series.__ne__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10382,18 +9544,16 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-
__rfloordiv__'pandas.core.series.Series.__rfloordiv__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*$"
+builtins.object"builtins.object*k
+__pow__!pandas.core.series.Series.__pow__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10420,17 +9580,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10457,18 +9614,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -10479,16 +9633,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10515,18 +9663,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rmod__"pandas.core.series.Series.__rmod__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10553,17 +9697,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10590,43 +9731,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+__rdiv__"pandas.core.series.Series.__rdiv__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.float$
 builtins.complex"builtins.complex	
@@ -10648,20 +9766,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*#
-__rmul__"pandas.core.series.Series.__rmul__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10688,18 +9800,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[Any]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -10710,19 +9819,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLikeD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*P
-__rnatmul__%pandas.core.series.Series.__rnatmul__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10749,18 +9849,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10787,39 +9883,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10846,18 +9917,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rpow__"pandas.core.series.Series.__rpow__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+__rdivmod__%pandas.core.series.Series.__rdivmod__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10884,17 +9952,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10921,18 +9987,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -10943,16 +10007,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -10979,20 +10037,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*:
-__rsub__"pandas.core.series.Series.__rsub__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11019,38 +10071,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11077,20 +10105,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*:
-__truediv__%pandas.core.series.Series.__truediv__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+
__rfloordiv__'pandas.core.series.Series.__rfloordiv__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11117,38 +10140,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11175,21 +10174,29 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-__invert__$pandas.core.series.Series.__invert__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11216,20 +10223,14 @@ __invert__$pandas.core.series.Series.__invert__"e
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-atpandas.core.series.Series.at"B
-pandas.core.indexing._AtIndexer"pandas.core.indexing._AtIndexer*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11256,20 +10257,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
-catpandas.core.series.Series.cat"h
-2pandas.core.arrays.categorical.CategoricalAccessor"2pandas.core.arrays.categorical.CategoricalAccessor*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11296,20 +10291,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
-iatpandas.core.series.Series.iat"D
- pandas.core.indexing._iAtIndexer" pandas.core.indexing._iAtIndexer*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+__rmod__"pandas.core.series.Series.__rmod__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11336,18 +10326,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*.
-ilocpandas.core.series.Series.iloc"
-8pandas.core.series._iLocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11374,18 +10360,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"%pandas.core.series._iLocIndexerSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11412,18 +10409,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*.
-locpandas.core.series.Series.loc"
-7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11450,18 +10443,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"$pandas.core.series._LocIndexerSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11488,18 +10477,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*X
-addpandas.core.series.Series.add"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+__rnatmul__%pandas.core.series.Series.__rnatmul__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11526,18 +10512,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11564,19 +10547,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11603,52 +10597,48 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *(
-axis
-builtins.int"builtins.int *
-allpandas.core.series.Series.all"
-
builtins.bool"
builtins.bool*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11675,35 +10665,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any*
-anypandas.core.series.Series.any"
-
builtins.bool"
builtins.bool*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+__rpow__"pandas.core.series.Series.__rpow__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11730,33 +10700,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any*1
-cummax pandas.core.series.Series.cummax"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11783,18 +10734,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11821,33 +10783,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*1
-cummin pandas.core.series.Series.cummin"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11874,18 +10817,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11912,33 +10851,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*1
-cumprod!pandas.core.series.Series.cumprod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*X
+__rsub__"pandas.core.series.Series.__rsub__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -11965,18 +10888,29 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12003,33 +10937,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*1
-cumsum pandas.core.series.Series.cumsum"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12056,18 +10971,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12094,36 +11005,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*?
-divide pandas.core.series.Series.divide"h
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*X
+__rtruediv__&pandas.core.series.Series.__rtruediv__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12150,19 +11042,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -12173,16 +11061,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12209,37 +11091,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *U
-divmod pandas.core.series.Series.divmod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12266,18 +11125,14 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12304,19 +11159,52 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*X
+__truediv__%pandas.core.series.Series.__truediv__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -12327,16 +11215,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12363,40 +11245,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *D
-eqpandas.core.series.Series.eq"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12423,37 +11279,14 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12480,41 +11313,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-ewmpandas.core.series.Series.ewm"
-Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+__invert__$pandas.core.series.Series.__invert__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12541,51 +11351,17 @@ Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-comJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *V
-spanJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *Z
-halflifeJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *W
-alphaJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None */
-min_periods
-builtins.int"builtins.int *,
-adjust
-
builtins.bool"
builtins.bool */
-	ignore_na
-
builtins.bool"
builtins.bool *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-	expanding#pandas.core.series.Series.expanding"
-Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+atpandas.core.series.Series.at"B
+pandas.core.indexing._AtIndexer"pandas.core.indexing._AtIndexer*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12612,37 +11388,17 @@ Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*/
-min_periods
-builtins.int"builtins.int *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod *@
-floordiv"pandas.core.series.Series.floordiv"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
+catpandas.core.series.Series.cat"h
+2pandas.core.arrays.categorical.CategoricalAccessor"2pandas.core.arrays.categorical.CategoricalAccessor*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12669,39 +11425,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
+iatpandas.core.series.Series.iat"D
+ pandas.core.indexing._iAtIndexer" pandas.core.indexing._iAtIndexer*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12728,42 +11462,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *D
-gepandas.core.series.Series.ge"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*'
+ilocpandas.core.series.Series.iloc"
+8pandas.core.series._iLocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12790,37 +11497,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"%pandas.core.series._iLocIndexerSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12847,40 +11532,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *D
-gtpandas.core.series.Series.gt"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*'
+locpandas.core.series.Series.loc"
+7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12907,37 +11567,50 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"$pandas.core.series._LocIndexerSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*M
+addpandas.core.series.Series.add"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12964,36 +11637,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-itempandas.core.series.Series.item"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13020,18 +11672,16 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13058,15 +11708,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*(
-kurtpandas.core.series.Series.kurt"
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -13084,11 +11730,27 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *(
+axis
+builtins.int"builtins.int *
+allpandas.core.series.Series.all"
+
builtins.bool"
builtins.bool*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13115,54 +11777,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+builtins.int"builtins.int"pandas._typing.AxisIndex *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
 None *,
 skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
 
builtins.bool"
builtins.bool *
 kwargs
-Any*(
-kurtosis"pandas.core.series.Series.kurtosis"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+anypandas.core.series.Series.any"
+
builtins.bool"
builtins.bool*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13189,38 +11829,30 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+builtins.int"builtins.int"pandas._typing.AxisIndex *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
 None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
+skipna
 
builtins.bool"
builtins.bool *
 kwargs
-Any*D
-lepandas.core.series.Series.le"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any**
+cummax pandas.core.series.Series.cummax"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13247,37 +11879,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13304,40 +11914,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *D
-ltpandas.core.series.Series.lt"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+args
+Any*
+kwargs
+Any**
+cummin pandas.core.series.Series.cummin"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13364,37 +11964,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13421,36 +11999,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *1
-maxpandas.core.series.Series.max"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+args
+Any*
+kwargs
+Any**
+cumprod!pandas.core.series.Series.cumprod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13477,18 +12049,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13515,14 +12084,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -13533,19 +12099,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.int"builtins.int"pandas._typing.AxisIndex
 None *,
 skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
+args
+Any*
 kwargs
-Any*
-meanpandas.core.series.Series.mean" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any**
+cumsum pandas.core.series.Series.cumsum"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13572,37 +12134,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*
-median pandas.core.series.Series.median" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13629,14 +12169,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -13647,54 +12184,18 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.int"builtins.int"pandas._typing.AxisIndex
 None *,
 skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
+args
+Any*
 kwargs
-Any*1
-minpandas.core.series.Series.min"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*]
+divide pandas.core.series.Series.divide"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13721,35 +12222,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*V
-modpandas.core.series.Series.mod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13776,18 +12272,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13814,39 +12306,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13873,14 +12340,11 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -13892,20 +12356,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fill_valueJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *V
-mulpandas.core.series.Series.mul"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *p
+divmod pandas.core.series.Series.divmod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13932,18 +12394,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13970,19 +12429,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -13993,16 +12449,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14029,77 +12479,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *V
-multiply"pandas.core.series.Series.multiply"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14126,39 +12513,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14185,14 +12547,11 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -14204,23 +12563,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fill_valueJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *D
-nepandas.core.series.Series.ne"e
+builtins.int"builtins.int"pandas._typing.AxisIndex *=
+eqpandas.core.series.Series.eq"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14247,15 +12604,12 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
@@ -14274,10 +12628,10 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14304,14 +12658,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -14330,13 +12681,15 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-nunique!pandas.core.series.Series.nunique"
-builtins.int"builtins.int*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+ewmpandas.core.series.Series.ewm"
+Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14363,20 +12716,41 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*,
-dropna
-
builtins.bool"
builtins.bool *V
-powpandas.core.series.Series.pow"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*U
+comJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *V
+spanJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *Z
+halflifeJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *W
+alphaJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None */
+min_periods
+builtins.int"builtins.int *,
+adjust
+
builtins.bool"
builtins.bool */
+	ignore_na
+
builtins.bool"
builtins.bool *
+	expanding#pandas.core.series.Series.expanding"
+Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14403,18 +12777,27 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*/
+min_periods
+builtins.int"builtins.int *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod *^
+floordiv"pandas.core.series.Series.floordiv"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14441,19 +12824,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -14464,16 +12844,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14500,14 +12874,79 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -14528,30 +12967,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *)
-prodpandas.core.series.Series.prod"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *=
+gepandas.core.series.Series.ge"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14578,36 +13001,13 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *-
-	min_count
-builtins.int"builtins.int *
-kwargs
-Any*)
-product!pandas.core.series.Series.product"
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -14625,11 +13025,10 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14656,39 +13055,37 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *-
-	min_count
-builtins.int"builtins.int *
-kwargs
-Any*Z
-raddpandas.core.series.Series.radd"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *=
+gtpandas.core.series.Series.gt"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14715,18 +13112,34 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14753,19 +13166,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *&
+itempandas.core.series.Series.item"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14792,14 +13219,47 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+kurtpandas.core.series.Series.kurt"
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -14817,30 +13277,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Z
-rdivmod!pandas.core.series.Series.rdivmod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14867,18 +13308,51 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*%
+kurtosis"pandas.core.series.Series.kurtosis"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14905,19 +13379,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*=
+lepandas.core.series.Series.le"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14944,14 +13434,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -14969,7 +13458,41 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -14988,11 +13511,14 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *3
-	rfloordiv#pandas.core.series.Series.rfloordiv"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *=
+ltpandas.core.series.Series.lt"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15019,18 +13545,34 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15057,16 +13599,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-Any*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -15085,11 +13622,10 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Z
-rmodpandas.core.series.Series.rmod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex **
+maxpandas.core.series.Series.max"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15116,18 +13652,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15154,19 +13687,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+meanpandas.core.series.Series.mean" 
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15193,55 +13741,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Z
-rmulpandas.core.series.Series.rmul"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+median pandas.core.series.Series.median" 
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15268,18 +13795,31 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any**
+minpandas.core.series.Series.min"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15306,19 +13846,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15345,55 +13881,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Z
-rpowpandas.core.series.Series.rpow"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*q
+modpandas.core.series.Series.mod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15420,18 +13933,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15458,19 +13968,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15497,55 +14018,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Z
-rsubpandas.core.series.Series.rsub"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15572,57 +14052,14 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15649,32 +14086,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -15686,18 +14102,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fill_valueJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *
-axis
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *3
-rtruediv"pandas.core.series.Series.rtruediv"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *q
+multiply"pandas.core.series.Series.multiply"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15724,18 +14142,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15762,58 +14177,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-Any*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-sempandas.core.series.Series.sem"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15840,58 +14227,14 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*(
-skewpandas.core.series.Series.skew"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15918,39 +14261,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*
-stdpandas.core.series.Series.std" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -15977,14 +14295,23 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -15993,23 +14320,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*V
-subpandas.core.series.Series.sub"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *=
+nepandas.core.series.Series.ne"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16036,18 +14354,34 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16074,39 +14408,36 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+nunique!pandas.core.series.Series.nunique"
+builtins.int"builtins.int*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16133,39 +14464,17 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *V
-subtract"pandas.core.series.Series.subtract"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*,
+dropna
+
builtins.bool"
builtins.bool *q
+powpandas.core.series.Series.pow"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16192,18 +14501,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16230,19 +14536,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -16253,16 +14556,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16289,39 +14586,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *-
-to_list!pandas.core.series.Series.to_list"
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16348,18 +14620,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16386,22 +14654,55 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *%
+prodpandas.core.series.Series.prod"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*2
-to_numpy"pandas.core.series.Series.to_numpy"9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16428,41 +14729,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-Union[TypeAlias[Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]]],None]
-
-TypeAlias[Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]]]
-Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]](
-numpy.dtype[Any]
-Any"numpy.dtype
-None
-
builtins.type"
builtins.type
-:numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]](
-numpy.dtype[Any]
-Any"numpy.dtype"(numpy._typing._dtype_like._SupportsDType
-builtins.str"builtins.str
-lTypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]
-aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]
-"Tuple[TypeAlias[Any],builtins.int]G
-TypeAlias[Any]
-Any"*numpy._typing._dtype_like._DTypeLikeNested
-builtins.int"builtins.int,
-builtins.list[Any]
-Any"
builtins.listM
-TypeAlias[TypedDict]
-	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike
-None **
-copy
-
builtins.bool"
builtins.bool *
-na_value
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *-
+	min_count
+builtins.int"builtins.int *
+kwargs
+Any*%
+product!pandas.core.series.Series.product"
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -16480,13 +14773,11 @@ aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[T
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar *
-kwargs
-Any*-
-tolist pandas.core.series.Series.tolist"
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16513,18 +14804,36 @@ aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[T
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *-
+	min_count
+builtins.int"builtins.int *
+kwargs
+Any*O
+raddpandas.core.series.Series.radd"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16551,21 +14860,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-truediv!pandas.core.series.Series.truediv"h
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16592,16 +14895,65 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-Any*
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -16620,30 +14972,82 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-varpandas.core.series.Series.var"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rdivmod!pandas.core.series.Series.rdivmod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16670,39 +15074,52 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*5
-set_axis"pandas.core.series.Series.set_axis"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *,
+	rfloordiv#pandas.core.series.Series.rfloordiv"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16729,18 +15146,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16767,37 +15181,36 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-Any*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+Any*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis **
-copy
-
builtins.bool"
builtins.bool *-
-__iter__"pandas.core.series.Series.__iter__"
-"typing.Iterator[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rmodpandas.core.series.Series.rmod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16824,17 +15237,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Iterator*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16861,22 +15272,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series2
-__new__!pandas.core.series.Series.__new__O
-__new__!pandas.core.series.Series.__new__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-cls
-2Type[pandas.core.series.Series[pandas._typing.S1]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16903,158 +15308,52 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series"type*
-data
-Union[pandas.core.indexes.datetimes.DatetimeIndex,typing.Sequence[Union[pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64,datetime.datetime]]]Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex
-ctyping.Sequence[Union[pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64,datetime.datetime]]
-RUnion[pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64,datetime.datetime]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp$
-numpy.datetime64"numpy.datetime64&
-datetime.datetime"datetime.datetime"typing.Sequence*
-
-index
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
 
-Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
-TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
-Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
-kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
-`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict 
-builtins.range"builtins.range.
-builtins.tuple[Any]
-Any"builtins.tuple"pandas._typing.Axes
-None *&
-dtype&
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.TimestampDtypeArg *Y
-nameM
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None **
-copy
-
builtins.bool"
builtins.bool 0:typing.overloadXS
-__new__!pandas.core.series.Series.__new__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-cls
-2Type[pandas.core.series.Series[pandas._typing.S1]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rpowpandas.core.series.Series.rpow"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -17081,170 +15380,4221 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series"type*	
-data
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike*
-
-index
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
 
-Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
-TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
-Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
-kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
-`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict 
-builtins.range"builtins.range.
-builtins.tuple[Any]
-Any"builtins.tuple"pandas._typing.Axes
-None *&
-dtype&
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rsubpandas.core.series.Series.rsub"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *,
+rtruediv"pandas.core.series.Series.rtruediv"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+Any*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *%
+sempandas.core.series.Series.sem"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *(
+ddof
+builtins.int"builtins.int *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*%
+skewpandas.core.series.Series.skew"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+stdpandas.core.series.Series.std" 
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.TimestampDtypeArg*Y
-nameM
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *(
+ddof
+builtins.int"builtins.int *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*q
+subpandas.core.series.Series.sub"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *q
+subtract"pandas.core.series.Series.subtract"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *&
+to_list!pandas.core.series.Series.to_list"
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*.
+to_numpy"pandas.core.series.Series.to_numpy"9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+Union[TypeAlias[Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]]],None]
+
+TypeAlias[Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]]]
+Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]](
+numpy.dtype[Any]
+Any"numpy.dtype
+None
+
builtins.type"
builtins.type
+:numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]](
+numpy.dtype[Any]
+Any"numpy.dtype"(numpy._typing._dtype_like._SupportsDType
+builtins.str"builtins.str
+lTypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]
+aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]
+"Tuple[TypeAlias[Any],builtins.int]G
+TypeAlias[Any]
+Any"*numpy._typing._dtype_like._DTypeLikeNested
+builtins.int"builtins.int,
+builtins.list[Any]
+Any"
builtins.listM
+TypeAlias[TypedDict]
+	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike
+None **
+copy
+
builtins.bool"
builtins.bool *
+na_value
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar *
+kwargs
+Any*&
+tolist pandas.core.series.Series.tolist"
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+truediv!pandas.core.series.Series.truediv"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+Any*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *%
+varpandas.core.series.Series.var"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *(
+ddof
+builtins.int"builtins.int *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*/
+set_axis"pandas.core.series.Series.set_axis"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+labels
+Any*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis **
+copy
+
builtins.bool"
builtins.bool *&
+__iter__"pandas.core.series.Series.__iter__"
+"typing.Iterator[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterator*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*-
+xspandas.core.series.Series.xs"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*+
+key"
+typing.Hashable"typing.Hashable*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *0
+
+drop_level
+
builtins.bool"
builtins.bool 2
+__new__!pandas.core.series.Series.__new__,
+__new__!pandas.core.series.Series.__new__"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*
+
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *	
+dtype	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadXO
+__new__!pandas.core.series.Series.__new__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+Union[pandas.core.indexes.datetimes.DatetimeIndex,typing.Sequence[Union[numpy.datetime64,datetime.datetime,datetime.date]],builtins.dict[pandas._typing.HashableT1,Union[numpy.datetime64,datetime.datetime,datetime.date]],numpy.datetime64,datetime.datetime,datetime.date]Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex
+Htyping.Sequence[Union[numpy.datetime64,datetime.datetime,datetime.date]]
+7Union[numpy.datetime64,datetime.datetime,datetime.date]$
+numpy.datetime64"numpy.datetime64&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date"typing.Sequence
+`builtins.dict[pandas._typing.HashableT1,Union[numpy.datetime64,datetime.datetime,datetime.date]]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable
+7Union[numpy.datetime64,datetime.datetime,datetime.date]$
+numpy.datetime64"numpy.datetime64&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date"
builtins.dict$
+numpy.datetime64"numpy.datetime64&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date*
+
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *&
+dtype&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadXt
+__new__!pandas.core.series.Series.__new__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*.
+data.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike*
+
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *&
+dtype&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg*.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadX#
+__new__!pandas.core.series.Series.__new__"B
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+`Union[pandas.core.indexes.period.PeriodIndex,typing.Sequence[pandas._libs.tslibs.period.Period]]P
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex
+2typing.Sequence[pandas._libs.tslibs.period.Period]F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period"typing.Sequence*
+
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *[
+dtypeN
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadXL
+__new__!pandas.core.series.Series.__new__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+Union[pandas.core.indexes.timedeltas.TimedeltaIndex,typing.Sequence[Union[numpy.timedelta64,datetime.timedelta]],builtins.dict[pandas._typing.HashableT1,Union[numpy.timedelta64,datetime.timedelta]],numpy.timedelta64,datetime.timedelta]^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex
+
-sort_values%pandas.core.series.Series.sort_values"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -21932,18 +24129,35 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+func
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+args
+Any*
+kwargs
+Any0:typing.overloadX
+	transform#pandas.core.series.Series.transform":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -21970,67 +24184,45 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+func
+Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
+Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
+YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
+Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.HashableV
+%Union[Unknown,builtins.list[Unknown]])
+builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame*
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX?
-sort_values%pandas.core.series.Series.sort_values"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+args
+Any*
+kwargs
+Any0:typing.overloadX2,
+applypandas.core.series.Series.apply
+applypandas.core.series.Series.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22057,19 +24249,27 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*U
+funcK
+CallableType[builtins.function]&
+builtins.function"builtins.function*2
+convertDType
+
builtins.bool"
builtins.bool *:
+args.
+builtins.tuple[Any]
+Any"builtins.tuple *
+kwds
+Any0:typing.overloadX
+applypandas.core.series.Series.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22096,72 +24296,28 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*U
+funcK
 CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2
-
-sort_index$pandas.core.series.Series.sort_index*
-
-sort_index$pandas.core.series.Series.sort_index"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.function"builtins.function*2
+convertDType
+
builtins.bool"
builtins.bool *:
+args.
+builtins.tuple[Any]
+Any"builtins.tuple *
+kwds
+Any0:typing.overloadX2
+rename pandas.core.series.Series.rename'
+rename pandas.core.series.Series.rename"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22188,15 +24344,27 @@ sort_index$pandas.core.series.Series.sort_index"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+index
+Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer"
+typing.Hashable"typing.Hashable
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -22210,57 +24378,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
 builtins.int"builtins.int"pandas._typing.Level
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
+None *
+errors
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX,
-
-sort_index$pandas.core.series.Series.sort_index"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX:
+rename pandas.core.series.Series.rename"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22287,85 +24430,16 @@ sort_index$pandas.core.series.Series.sort_index"D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX-
-
-sort_index$pandas.core.series.Series.sort_index"~
-*Union[pandas.core.series.Series[Any],None]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22392,15 +24466,26 @@ sort_index$pandas.core.series.Series.sort_index"~
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+index
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -22414,96 +24499,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2l
-	aggregate#pandas.core.series.Series.aggregate2
-	aggregate#pandas.core.series.Series.aggregate"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX6
+rename pandas.core.series.Series.rename"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22530,36 +24551,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX9
-	aggregate#pandas.core.series.Series.aggregate"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22586,18 +24587,60 @@ JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*Z
+indexM
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX'
+rename pandas.core.series.Series.rename"~
+*Union[pandas.core.series.Series[Any],None]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22624,44 +24667,67 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-TypeAlias[Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]]
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+index
+Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
 CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
-0typing.Mapping[pandas._typing.HashableT,Unknown]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries"'pandas._typing.AggFuncTypeSeriesToFrame *
-axis
+builtins.function"builtins.function"pandas._typing.Renamer"
+typing.Hashable"typing.Hashable
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX2V
-	transform#pandas.core.series.Series.transform3
-	transform#pandas.core.series.Series.transform"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *-
+inplace
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
+fillna pandas.core.series.Series.fillna>
+fillna pandas.core.series.Series.fillna"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22688,18 +24754,38 @@ JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+value%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22726,38 +24812,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX"
-	transform#pandas.core.series.Series.transform":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadXQ
+fillna pandas.core.series.Series.fillna"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22784,48 +24869,15 @@ JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX23
-applypandas.core.series.Series.apply
-applypandas.core.series.Series.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22852,30 +24904,38 @@ Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+value%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*2
-convertDType
-
builtins.bool"
builtins.bool *:
-args.
-builtins.tuple[Any]
-Any"builtins.tuple *
-kwds
-Any0:typing.overloadX
-applypandas.core.series.Series.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22902,31 +24962,38 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*2
-convertDType
-
builtins.bool"
builtins.bool *:
-args.
-builtins.tuple[Any]
-Any"builtins.tuple *
-kwds
-Any0:typing.overloadX2
-rename pandas.core.series.Series.rename*
-rename pandas.core.series.Series.rename"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadXQ
+fillna pandas.core.series.Series.fillna"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -22953,71 +25020,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-index
-Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
-lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
-aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
-:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
-Any
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label"typing.MappingK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Renamer"
-typing.Hashable"typing.Hashable
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX*
-rename pandas.core.series.Series.rename"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23044,70 +25056,38 @@ aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[b
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+value%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-index
-xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
-lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
-aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
-:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
-Any
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label"typing.MappingK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Renamer
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX%
-rename pandas.core.series.Series.rename"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23134,63 +25114,72 @@ aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[b
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*Z
-indexM
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX+
-rename pandas.core.series.Series.rename"~
-*Union[pandas.core.series.Series[Any],None]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *-
+inplace
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2
+replace!pandas.core.series.Series.replaceS
+replace!pandas.core.series.Series.replace"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23217,70 +25206,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-index
-Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
-lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
-aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
-:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
-Any
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label"typing.MappingK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Renamer"
-typing.Hashable"typing.Hashable
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *-
-inplace
-
builtins.bool"
builtins.bool *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
-droppandas.core.series.Series.drop+
-droppandas.core.series.Series.drop"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+to_replace
+~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
+builtins.str"builtins.str,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23307,77 +25249,65 @@ aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[b
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series 
+builtins.float"builtins.float
+None *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT2],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT2]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-columns
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT3]R
-pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *G
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict,
+builtins.list[Any]
+Any"
builtins.list
+builtins.str"builtins.str
+None *I
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX,
-droppandas.core.series.Series.drop"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX@
+replace!pandas.core.series.Series.replace"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23404,79 +25334,107 @@ cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.inde
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+to_replace
+~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
+builtins.str"builtins.str,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series 
+builtins.float"builtins.float
+None *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict,
+builtins.list[Any]
+Any"
builtins.list
+builtins.str"builtins.str
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT2],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT2]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-columns
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT3]R
-pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX,
-droppandas.core.series.Series.drop"~
-*Union[pandas.core.series.Series[Any],None]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.ReplaceMethod *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadXT
+replace!pandas.core.series.Series.replace"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23503,76 +25461,16 @@ cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.inde
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT2],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT2]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-columns
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT3]R
-pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *-
-inplace
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
-fillna pandas.core.series.Series.fillnaI
-fillna pandas.core.series.Series.fillna"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23599,16 +25497,58 @@ cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.inde
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+to_replace
+~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
+builtins.str"builtins.str,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
-value)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series 
+builtins.float"builtins.float
+None *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -23630,10 +25570,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 pandas._libs.missing.NAType"pandas._libs.missing.NAType9
 builtins.dict[Any,Any]
 Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
builtins.dict,
+builtins.list[Any]
+Any"
builtins.list
+builtins.str"builtins.str
+None *-
+inplace
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX2o
+dropna pandas.core.series.Series.dropna
+dropna pandas.core.series.Series.dropna"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23660,53 +25625,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None *
-method
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions
-None *
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None *G
+builtins.int"builtins.int"pandas._typing.AxisIndex *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX`
-fillna pandas.core.series.Series.fillna"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None 0:typing.overloadX+
+dropna pandas.core.series.Series.dropna"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23733,18 +25677,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23771,41 +25712,69 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
-value)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None 0:typing.overloadX+
+dropna pandas.core.series.Series.dropna"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23832,54 +25801,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None *
-method
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions
-None *
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadXa
-fillna pandas.core.series.Series.fillna"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *-
+inplace
+
builtins.bool"
builtins.bool *
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None 0:typing.overloadX2
+astype pandas.core.series.Series.astype 
+astype pandas.core.series.Series.astype"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23906,19 +25856,49 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXs
+astype pandas.core.series.Series.astype"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23945,41 +25925,187 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
-value)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*[
+dtype[
+Union[TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]]&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX 
+astype pandas.core.series.Series.astype"b
+'pandas.core.series.Series[builtins.str]
+builtins.str"builtins.str"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24006,20 +26132,25 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None *
-method
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*	
+dtype	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -24027,32 +26158,27 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-inplace
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2
-replace!pandas.core.series.Series.replace^
-replace!pandas.core.series.Series.replace"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+astype pandas.core.series.Series.astype"h
+)pandas.core.series.Series[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24079,18 +26205,46 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX5
+astype pandas.core.series.Series.astype"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24117,26 +26271,98 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-to_replace
-~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
-builtins.str"builtins.str,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+$Type[numpy.floating[TypeAlias[Any]]]l
+numpy.floating[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitHalf"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX,
+astype pandas.core.series.Series.astype"n
++pandas.core.series.Series[builtins.complex]$
+builtins.complex"builtins.complex"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24163,68 +26389,75 @@ to_replace
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series 
-builtins.float"builtins.float
-None *
-value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list
-builtins.str"builtins.str
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-regex
-Any *
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str
+3Type[numpy.complexfloating[TypeAlias[Any],Unknown]]
+-numpy.complexfloating[TypeAlias[Any],Unknown]<
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitSingle"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadXG
-replace!pandas.core.series.Series.replace"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX;
+astype pandas.core.series.Series.astype"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24251,26 +26484,121 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-to_replace
-~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
-builtins.str"builtins.str,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*$
+dtype$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX=
+astype pandas.core.series.Series.astype"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24297,67 +26625,126 @@ to_replace
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series 
-builtins.float"builtins.float
-None *
-value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list
-builtins.str"builtins.str
-None *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-regex
-Any *
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*&
+dtype&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ReplaceMethod *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX^
-replace!pandas.core.series.Series.replace"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+astype pandas.core.series.Series.astype"
+Epandas.core.series.Series[pandas.core.dtypes.dtypes.CategoricalDtype]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24384,19 +26771,33 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX$
+astype pandas.core.series.Series.astype"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24423,26 +26824,57 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+Union[TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
 
-to_replace
-~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
-builtins.str"builtins.str,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArgP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2E
+ffillpandas.core.series.Series.ffill
+ffillpandas.core.series.Series.ffill"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24469,68 +26901,37 @@ to_replace
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series 
-builtins.float"builtins.float
-None *
-value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list
-builtins.str"builtins.str
-None *-
-inplace
-
builtins.bool"
builtins.bool *Q
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*Q
 limitD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None *
-regex
-Any *
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX2
-dropna pandas.core.series.Series.dropna
-dropna pandas.core.series.Series.dropna"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX,
+ffillpandas.core.series.Series.ffill"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24557,35 +26958,15 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-how
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None 0:typing.overloadX2
-dropna pandas.core.series.Series.dropna"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24612,18 +26993,40 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2ř
+bfillpandas.core.series.Series.bfill
+bfillpandas.core.series.Series.bfill"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24650,36 +27053,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *I
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-how
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None 0:typing.overloadX2
-dropna pandas.core.series.Series.dropna"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX,
+bfillpandas.core.series.Series.bfill"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24705,20 +27109,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Type[builtins.object]"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24745,38 +27145,38 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-inplace
-
builtins.bool"
builtins.bool *
-how
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None 0:typing.overloadX2֔
-astype pandas.core.series.Series.astype$
-astype pandas.core.series.Series.astype"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadXS
+bfillpandas.core.series.Series.bfill"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24803,54 +27203,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*	
-dtype	
-TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"type7
-Literal[builtins.str]	
-builtins.str"builtins.strR
-'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Type[numpy.bool_]
-numpy.bool_"numpy.bool_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.BooleanDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXx
-astype pandas.core.series.Series.astype"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24869,202 +27231,23 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 
numpy.generic"
numpy.generic"numpy.dtype:
 Type[builtins.str]
 builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*]
-dtype]
-Union[TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]]'
-TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
-Type[builtins.int]
-builtins.int"builtins.int"type7
-Literal[builtins.str]	
-builtins.str"builtins.strL
-$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
-%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
-%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
-%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-)Type[numpy.signedinteger[TypeAlias[Any]]]v
-#numpy.signedinteger[TypeAlias[Any]]:
-TypeAlias[Any]
-Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IntDtypeArg%
-TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
-%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
-&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
-&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
-&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.UIntDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX$
-astype pandas.core.series.Series.astype"b
-'pandas.core.series.Series[builtins.str]
-builtins.str"builtins.str"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*'
+value'
+xUnion[pandas._typing.S1,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25091,56 +27274,76 @@ $Type[numpy.unsignedinteger[Unknown]]9
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*	
-dtype	
-TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
 Type[builtins.str]
-builtins.str"builtins.str"type7
-Literal[builtins.str]	
-builtins.str"builtins.strP
-&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
-Literal[builtins.str]	
-builtins.str"builtins.str4
-Type[numpy.str_]
-
-numpy.str_"
-numpy.str_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.StrDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX"
-astype pandas.core.series.Series.astype"h
-)pandas.core.series.Series[builtins.bytes] 
-builtins.bytes"builtins.bytes"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *-
+inplace
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2.
+value_counts&pandas.core.series.Series.value_counts
+value_counts&pandas.core.series.Series.value_counts"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25167,51 +27370,31 @@ numpy.str_"type7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
-Type[builtins.bytes] 
-builtins.bytes"builtins.bytes"type7
-Literal[builtins.str]	
-builtins.str"builtins.str:
-Type[numpy.bytes_]
-numpy.bytes_"numpy.bytes_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.BytesDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX9
-astype pandas.core.series.Series.astype"h
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*K
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *P
+binsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+value_counts&pandas.core.series.Series.value_counts"h
 )pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25238,101 +27421,65 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*I
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool**
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *P
+binsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX2ϗ
+__add__!pandas.core.series.Series.__add__O
+__add__!pandas.core.series.Series.__add__"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
-Type[builtins.float] 
-builtins.float"builtins.float"type7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
-(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-$Type[numpy.floating[TypeAlias[Any]]]l
-numpy.floating[TypeAlias[Any]]:
-TypeAlias[Any]
-Any"numpy._typing._nbit._NBitHalf"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-Type[numpy.floating[Unknown]]+
-numpy.floating[Unknown]"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-Type[numpy.floating[Unknown]]+
-numpy.floating[Unknown]"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-Type[numpy.floating[Unknown]]+
-numpy.floating[Unknown]"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FloatDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX0
-astype pandas.core.series.Series.astype"n
-+pandas.core.series.Series[builtins.complex]$
-builtins.complex"builtins.complex"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25359,78 +27506,49 @@ $Type[numpy.floating[TypeAlias[Any]]]l
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*'&
+7Union[pandas._typing.S1,pandas.core.series.Series.Self]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
 Type[builtins.complex]$
-builtins.complex"builtins.complex"type7
-Literal[builtins.str]	
-builtins.str"builtins.str
-3Type[numpy.complexfloating[TypeAlias[Any],Unknown]]
--numpy.complexfloating[TypeAlias[Any],Unknown]<
-TypeAlias[Any]
-Any"numpy._typing._nbit._NBitSingle"numpy.complexfloating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str{
-,Type[numpy.complexfloating[Unknown,Unknown]]C
-&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str{
-,Type[numpy.complexfloating[Unknown,Unknown]]C
-&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ComplexDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX?
-astype pandas.core.series.Series.astype"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25457,124 +27575,103 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(0:typing.overloadXH
+__add__!pandas.core.series.Series.__add__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$
-dtype$
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXA
-astype pandas.core.series.Series.astype"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*33
+Union[builtins.complex,builtins.str,datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any],numpy.timedelta64]$
+builtins.complex"builtins.complex
+builtins.str"builtins.str(
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25601,129 +27698,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*&
-dtype&
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.TimestampDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
-astype pandas.core.series.Series.astype"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series&
+numpy.timedelta64"numpy.timedelta640:typing.overloadX28
+__and__!pandas.core.series.Series.__and__
+__and__!pandas.core.series.Series.__and__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25750,36 +27739,171 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
+
builtins.bool"
builtins.boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.listJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__and__!pandas.core.series.Series.__and__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
-GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.CategoryDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX(
-astype pandas.core.series.Series.astype"D
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2]
+__mul__!pandas.core.series.Series.__mul__
+__mul__!pandas.core.series.Series.__mul__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta640:typing.overloadXE
+__mul__!pandas.core.series.Series.__mul__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25806,60 +27930,14 @@ GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-Union[TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
-gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
-\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
-Type[builtins.object]"
-builtins.object"builtins.object"type7
-Literal[builtins.str]	
-builtins.str"builtins.str=
-Type[numpy.object_]
-
numpy.object_"
numpy.object_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
-dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
-Type[numpy.void]
-
-numpy.void"
-numpy.void"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.VoidDtypeArgP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
-HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtypeP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2P
-ffillpandas.core.series.Series.ffill
-ffillpandas.core.series.Series.ffill"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25886,40 +27964,20 @@ HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX3
-ffillpandas.core.series.Series.ffill"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__or__ pandas.core.series.Series.__or__
+__or__ pandas.core.series.Series.__or__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25946,18 +28004,32 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
+
builtins.bool"
builtins.boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.listJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__or__ pandas.core.series.Series.__or__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25984,43 +28056,28 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2IJ
-bfillpandas.core.series.Series.bfill
-bfillpandas.core.series.Series.bfill"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2
+__radd__"pandas.core.series.Series.__radd__N
+__radd__"pandas.core.series.Series.__radd__"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26047,40 +28104,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX3
-bfillpandas.core.series.Series.bfill"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26107,18 +28139,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*&&
+EUnion[pandas._typing.S1,pandas.core.series.Series[pandas._typing.S1]]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26145,41 +28173,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadXb
-bfillpandas.core.series.Series.bfill"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26206,19 +28207,17 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:typing.overloadXF
+__radd__"pandas.core.series.Series.__radd__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26245,18 +28244,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*/
-value/
-xUnion[pandas._typing.S1,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,builtins.str,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex
+builtins.str"builtins.str.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26280,23 +28291,17 @@ xUnion[pandas._typing.S1,builtins.dict[Any,Any],pandas.core.series.Series[pandas
 Type[builtins.bool]
 
builtins.bool"
builtins.bool"typeC
 Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26323,40 +28328,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-inplace
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2φ
-__add__!pandas.core.series.Series.__add__
-__add__!pandas.core.series.Series.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__rand__"pandas.core.series.Series.__rand__
+__rand__"pandas.core.series.Series.__rand__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26383,20 +28368,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*JH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadX
-__add__!pandas.core.series.Series.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
+
builtins.bool"
builtins.boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.listJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__rand__"pandas.core.series.Series.__rand__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26423,20 +28420,28 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
-__add__!pandas.core.series.Series.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2]
+__rmul__"pandas.core.series.Series.__rmul__
+__rmul__"pandas.core.series.Series.__rmul__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26463,21 +28468,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*VT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:typing.overloadX<
-__add__!pandas.core.series.Series.__add__"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta640:typing.overloadXE
+__rmul__"pandas.core.series.Series.__rmul__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26504,20 +28510,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$$
-Union[builtins.complex,builtins.str,pandas._libs.tslibs.timedeltas.Timedelta,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],numpy.timedelta64]$
-builtins.complex"builtins.complex
-builtins.str"builtins.strT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -26528,16 +28529,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26564,22 +28559,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX2?
-__and__!pandas.core.series.Series.__and__ 
-__and__!pandas.core.series.Series.__and__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26606,35 +28593,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
-
builtins.bool"
builtins.boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.listJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__ror__!pandas.core.series.Series.__ror__
+__ror__!pandas.core.series.Series.__ror__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__and__!pandas.core.series.Series.__and__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26661,31 +28633,32 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
+
builtins.bool"
builtins.boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.listJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__ror__!pandas.core.series.Series.__ror__"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2>
-__mul__!pandas.core.series.Series.__mul__
-__mul__!pandas.core.series.Series.__mul__"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26712,24 +28685,29 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX$
-__mul__!pandas.core.series.Series.__mul__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX28
+__rxor__"pandas.core.series.Series.__rxor__
+__rxor__"pandas.core.series.Series.__rxor__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26756,44 +28734,32 @@ dUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeri
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[Any]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLikeD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series0:typing.overloadX2?
-__or__ pandas.core.series.Series.__or__ 
-__or__ pandas.core.series.Series.__or__"e
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
+
builtins.bool"
builtins.boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.listJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__rxor__"pandas.core.series.Series.__rxor__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26820,35 +28786,87 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
-
builtins.bool"
builtins.boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.listJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__or__ pandas.core.series.Series.__or__"b
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2i
+__sub__!pandas.core.series.Series.__sub__
+__sub__!pandas.core.series.Series.__sub__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+Cpandas.core.series.Series[pandas._libs.tslibs.timestamps.Timestamp]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas.core.series.Series*
+Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
+__sub__!pandas.core.series.Series.__sub__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series*
+Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
+__sub__!pandas.core.series.Series.__sub__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.series.TimestampSeries]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp&
+datetime.datetime"datetime.datetimeH
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadXE
+__sub__!pandas.core.series.Series.__sub__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26875,32 +28893,29 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2?
-__rand__"pandas.core.series.Series.__rand__ 
-__rand__"pandas.core.series.Series.__rand__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26927,35 +28942,14 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
-
builtins.bool"
builtins.boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.listJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__rand__"pandas.core.series.Series.__rand__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -26982,32 +28976,20 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2?
-__ror__!pandas.core.series.Series.__ror__ 
-__ror__!pandas.core.series.Series.__ror__"e
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__xor__!pandas.core.series.Series.__xor__
+__xor__!pandas.core.series.Series.__xor__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27034,14 +29016,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
 
builtins.bool"
builtins.boolM
 builtins.list[builtins.bool]
@@ -27056,13 +29035,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__ror__!pandas.core.series.Series.__ror__"b
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__xor__!pandas.core.series.Series.__xor__"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27089,14 +29068,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
 builtins.int"builtins.int
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -27107,14 +29083,14 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2S
-__rtruediv__&pandas.core.series.Series.__rtruediv__
-__rtruediv__&pandas.core.series.Series.__rtruediv__"h
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2i
+mulpandas.core.series.Series.mul
+mulpandas.core.series.Series.mul"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27141,21 +29117,45 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX:
-__rtruediv__&pandas.core.series.Series.__rtruediv__"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta64*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None 0:typing.overloadXK
+mulpandas.core.series.Series.mul"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27182,18 +29182,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*1
+other1
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -27204,57 +29202,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:typing.overloadX2?
-__rxor__"pandas.core.series.Series.__rxor__ 
-__rxor__"pandas.core.series.Series.__rxor__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27281,35 +29232,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
-
builtins.bool"
builtins.boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.listJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__rxor__"pandas.core.series.Series.__rxor__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27336,49 +29266,41 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2K
-__sub__!pandas.core.series.Series.__sub__
-__sub__!pandas.core.series.Series.__sub__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-Cpandas.core.series.Series[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas.core.series.Series*
-Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
-__sub__!pandas.core.series.Series.__sub__"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series*
-Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
-__sub__!pandas.core.series.Series.__sub__"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None 0:typing.overloadX2g
+rmulpandas.core.series.Series.rmul
+rmulpandas.core.series.Series.rmul"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27405,24 +29327,43 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.series.TimestampSeries]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp&
-datetime.datetime"datetime.datetimeH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadX$
-__sub__!pandas.core.series.Series.__sub__"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta64*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex 0:typing.overloadXJ
+rmulpandas.core.series.Series.rmul"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27449,18 +29390,16 @@ dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.se
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[Any]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*1
+other1
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -27471,22 +29410,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLikeD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series0:typing.overloadX2?
-__xor__!pandas.core.series.Series.__xor__ 
-__xor__!pandas.core.series.Series.__xor__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27513,35 +29440,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
-
builtins.bool"
builtins.boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.listJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__xor__!pandas.core.series.Series.__xor__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27568,34 +29474,41 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2P
-rolling!pandas.core.series.Series.rolling'
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex 0:typing.overloadX2D
+rolling!pandas.core.series.Series.rolling"
 rolling!pandas.core.series.Series.rolling"
 Apandas.core.window.rolling.Window[pandas.core.series.Series[Any]]D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"!pandas.core.window.rolling.Window*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series"!pandas.core.window.rolling.Window*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27622,14 +29535,11 @@ Apandas.core.window.rolling.Window[pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 window
 {Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
 builtins.int"builtins.int
@@ -27646,14 +29556,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 onD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
+None *
 closed
 uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
@@ -27679,15 +29582,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str" pandas._typing.CalculationMethod **
 win_type
-builtins.str"builtins.str0:typing.overloadX'
+builtins.str"builtins.str0:typing.overloadX"
 rolling!pandas.core.series.Series.rolling"
 Bpandas.core.window.rolling.Rolling[pandas.core.series.Series[Any]]D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series""pandas.core.window.rolling.Rolling*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series""pandas.core.window.rolling.Rolling*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27714,14 +29617,11 @@ Bpandas.core.window.rolling.Rolling[pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 window
 {Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
 builtins.int"builtins.int
@@ -27738,14 +29638,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 onD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
+None *
 closed
 uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
@@ -27771,7 +29664,7 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str" pandas._typing.CalculationMethod *
 win_type
-None 0:typing.overloadX2>
+None 0:typing.overloadX27
 sumpandas.core.series.Series.sum
 sumpandas.core.series.Series.sum"
 Any*X
@@ -27825,10 +29718,10 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 	min_count
 builtins.int"builtins.int *
 kwargs
-Any0:typing.overloadX2
-sumpandas.core.series.Series.sum"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any0:typing.overloadX+
+sumpandas.core.series.Series.sum"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27855,18 +29748,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27893,14 +29783,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -27921,14 +29808,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 	min_count
 builtins.int"builtins.int *
 kwargs
-Any0:typing.overloadX2΢
-rename_axis%pandas.core.series.Series.rename_axisP
+Any0:typing.overloadX2
+rename_axis%pandas.core.series.Series.rename_axisM
 rename_axis%pandas.core.series.Series.rename_axis"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27955,14 +29842,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 mapper
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._typing.ListLike]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -28054,14 +29938,12 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 
builtins.bool"
builtins.bool *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadXQ
-rename_axis%pandas.core.series.Series.rename_axis"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool0:typing.overloadXa
+rename_axis%pandas.core.series.Series.rename_axis"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28088,14 +29970,47 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
 mapper
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._typing.ListLike]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -28194,19 +30109,20 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 CallableType[builtins.function]&
 builtins.function"builtins.function"builtins.functionrR
 sparse pandas.core.series.Series.sparse&
-builtins.ellipsis"builtins.ellipsis/
+builtins.ellipsis"builtins.ellipsis3
 TimestampSeries"pandas.core.series.TimestampSeries"pandas.core.series.Series*
 dt%pandas.core.series.TimestampSeries.dt"f
 1pandas.core.indexes.accessors.TimestampProperties"1pandas.core.indexes.accessors.TimestampProperties*R
 selfH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:builtins.property`*
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:builtins.property`*
 __add__*pandas.core.series.TimestampSeries.__add__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*JH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-NUnion[pandas.core.series.TimedeltaSeries,numpy.timedelta64,datetime.timedelta]H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+uUnion[pandas.core.series.TimedeltaSeries,numpy.timedelta64,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset]H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
 numpy.timedelta64"numpy.timedelta64(
-datetime.timedelta"datetime.timedelta*
+datetime.timedelta"datetime.timedeltaP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
 __radd__+pandas.core.series.TimestampSeries.__radd__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*JH
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
@@ -28302,7 +30218,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 numeric_only
 
builtins.bool"
builtins.bool *
 kwargs
-Any2	
+Any*
+diff'pandas.core.series.TimestampSeries.diff"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*R
+selfH
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*+
+periods
+builtins.int"builtins.int 2
+
 __sub__*pandas.core.series.TimestampSeries.__sub__
 __sub__*pandas.core.series.TimestampSeries.__sub__"H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*JH
@@ -28310,20 +30233,22 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.series.TimestampSeries]T
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp&
 datetime.datetime"datetime.datetimeH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadX
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadX
 __sub__*pandas.core.series.TimestampSeries.__sub__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*JH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-|Union[datetime.timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64](
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+Union[datetime.timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64,pandas._libs.tslibs.offsets.BaseOffset](
 datetime.timedelta"datetime.timedeltaH
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX9
-TimedeltaSeries"pandas.core.series.TimedeltaSeries"pandas.core.series.Series*
+numpy.timedelta64"numpy.timedelta64P
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadXS
+TimedeltaSeries"pandas.core.series.TimedeltaSeries"pandas.core.series.Series*
 __radd__+pandas.core.series.TimedeltaSeries.__radd__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-RUnion[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.series.TimestampSeries]T
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+dUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,pandas.core.series.TimestampSeries]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampH
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
 __mul__*pandas.core.series.TimedeltaSeries.__mul__"H
@@ -28336,24 +30261,38 @@ RUnion[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.series.TimestampSeri
 'pandas.core.series.Series[builtins.int]
 builtins.int"builtins.int"pandas.core.series.Seriesh
 )pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
+builtins.float"builtins.float"pandas.core.series.Series*
 __sub__*pandas.core.series.TimedeltaSeries.__sub__"H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+Union[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
-numpy.timedelta64"numpy.timedelta64*
-__truediv__.pandas.core.series.TimedeltaSeries.__truediv__"h
+numpy.timedelta64"numpy.timedelta64*
+__rtruediv__/pandas.core.series.TimedeltaSeries.__rtruediv__"h
 )pandas.core.series.Series[builtins.float] 
 builtins.float"builtins.float"pandas.core.series.Series*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64,pandas.core.indexes.timedeltas.TimedeltaIndex]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+Union[datetime.timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64,pandas.core.indexes.timedeltas.TimedeltaIndex,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta64^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence*
+
__rfloordiv__0pandas.core.series.TimedeltaSeries.__rfloordiv__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*JH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+Union[datetime.timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64,pandas.core.indexes.timedeltas.TimedeltaIndex,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedeltaH
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
 numpy.timedelta64"numpy.timedelta64^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence*
 dt%pandas.core.series.TimedeltaSeries.dt"f
 1pandas.core.indexes.accessors.TimedeltaProperties"1pandas.core.indexes.accessors.TimedeltaProperties*R
 selfH
@@ -28424,50 +30363,75 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 numeric_only
 
builtins.bool"
builtins.bool *
 kwargs
-Any*
-xs%pandas.core.series.TimedeltaSeries.xs"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*R
+Any*
+diff'pandas.core.series.TimedeltaSeries.diff"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*R
 selfH
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*+
-key"
-typing.Hashable"typing.Hashable*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *0
-
-drop_level
-
builtins.bool"
builtins.bool 2
-
+periods
+builtins.int"builtins.int 2
 __add__*pandas.core.series.TimedeltaSeries.__add__
 __add__*pandas.core.series.TimedeltaSeries.__add__"B
 pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*JH
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
 __add__*pandas.core.series.TimedeltaSeries.__add__"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-~Union[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]T
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+Union[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampH
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeriesZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
 __add__*pandas.core.series.TimedeltaSeries.__add__"H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-AUnion[pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedelta64]T
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+TUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
+numpy.timedelta64"numpy.timedelta640:typing.overloadX2
+__truediv__.pandas.core.series.TimedeltaSeries.__truediv__
+__truediv__.pandas.core.series.TimedeltaSeries.__truediv__"
+'pandas.core.series.TimedeltaSeries.SelfH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries(*
+'pandas.core.series.TimedeltaSeries.SelfH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries(*
+5Union[builtins.float,typing.Sequence[builtins.float]] 
+builtins.float"builtins.floatT
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence0:typing.overloadX
+__truediv__.pandas.core.series.TimedeltaSeries.__truediv__"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*JH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+Union[datetime.timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64,pandas.core.indexes.timedeltas.TimedeltaIndex,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta64^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence0:typing.overloadX2
+__floordiv__/pandas.core.series.TimedeltaSeries.__floordiv__
+__floordiv__/pandas.core.series.TimedeltaSeries.__floordiv__"
+'pandas.core.series.TimedeltaSeries.SelfH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries(*
+'pandas.core.series.TimedeltaSeries.SelfH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries(*
+5Union[builtins.float,typing.Sequence[builtins.float]] 
+builtins.float"builtins.floatT
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence0:typing.overloadX
+__floordiv__/pandas.core.series.TimedeltaSeries.__floordiv__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*JH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+Union[datetime.timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64,pandas.core.indexes.timedeltas.TimedeltaIndex,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta64^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence0:typing.overloadX
 PeriodSeriespandas.core.series.PeriodSeries"pandas.core.series.Series*
 dt"pandas.core.series.PeriodSeries.dt"`
 .pandas.core.indexes.accessors.PeriodProperties".pandas.core.indexes.accessors.PeriodProperties*L
@@ -28476,7 +30440,13 @@ AUnion[pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedelta64]T
 __sub__'pandas.core.series.PeriodSeries.__sub__"B
 pandas.core.series.OffsetSeries"pandas.core.series.OffsetSeries*DB
 pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*DB
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*
+diff$pandas.core.series.PeriodSeries.diff"B
+pandas.core.series.OffsetSeries"pandas.core.series.OffsetSeries*L
+selfB
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*+
+periods
+builtins.int"builtins.int 
 OffsetSeriespandas.core.series.OffsetSeries"pandas.core.series.Series2
 __radd__(pandas.core.series.OffsetSeries.__radd__
 __radd__(pandas.core.series.OffsetSeries.__radd__"B
@@ -28486,7 +30456,8 @@ AUnion[pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedelta64]T
 __radd__(pandas.core.series.OffsetSeries.__radd__"B
 pandas.core.series.OffsetSeries"pandas.core.series.OffsetSeries*DB
 pandas.core.series.OffsetSeries"pandas.core.series.OffsetSeries*RP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX
+
 IntervalSeries!pandas.core.series.IntervalSeries"pandas.core.series.Series*
 array'pandas.core.series.IntervalSeries.array"V
 )pandas.core.arrays.interval.IntervalArray")pandas.core.arrays.interval.IntervalArray*
@@ -28497,7 +30468,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"!pandas.core.series.IntervalSeries0:builtins.property`P*
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"!pandas.core.series.IntervalSeries0:builtins.property`*
+diff&pandas.core.series.IntervalSeries.diff"
+NoReturn
+*
+self
+Dpandas.core.series.IntervalSeries[pandas._libs.interval._OrderableT]
+!pandas._libs.interval._OrderableT
+tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"!pandas.core.series.IntervalSeries*+
+periods
+builtins.int"builtins.int P*
 __annotations__"pandas.core.series.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.strings.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.strings.protobuf
index b0de02fe93..98c86027a7 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.strings.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.strings.protobuf
@@ -1,69 +1,85 @@
 
-pandas.core.strings
-
StringMethods!pandas.core.strings.StringMethods"%pandas.core.base.NoNewAttributesMixin*
+pandas.core.strings
+
StringMethods!pandas.core.strings.StringMethods"%pandas.core.base.NoNewAttributesMixin*
 __init__*pandas.core.strings.StringMethods.__init__"
-None*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+None*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*S
 dataI
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
+builtins.object"builtins.object"builtins.object*
 __getitem__-pandas.core.strings.StringMethods.__getitem__"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*hf
 "Union[builtins.slice,builtins.int] 
 builtins.slice"builtins.slice
-builtins.int"builtins.int*
+builtins.int"builtins.int*
 __iter__*pandas.core.strings.StringMethods.__iter__"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 get%pandas.core.strings.StringMethods.get"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*#
 i
-builtins.int"builtins.int*
+builtins.int"builtins.int*
 join&pandas.core.strings.StringMethods.join"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sep
-builtins.str"builtins.str*
+builtins.str"builtins.str*
 contains*pandas.core.strings.StringMethods.contains"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
-pat
-builtins.str"builtins.str**
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*v
+patm
+#Union[builtins.str,re.Pattern[Any]]
+builtins.str"builtins.str&
+re.Pattern[Any]
+Any"
+re.Pattern**
 case
 
builtins.bool"
builtins.bool *)
 flags
@@ -71,15 +87,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 na
 Any *+
 regex
-
builtins.bool"
builtins.bool *
-match'pandas.core.strings.StringMethods.match"I
-pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool *
+match'pandas.core.strings.StringMethods.match"P
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 pat
 builtins.str"builtins.str**
@@ -88,15 +106,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 flags
 builtins.int"builtins.int *
 na
-Any *
+Any *
 replace)pandas.core.strings.StringMethods.replace"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 pat
 builtins.str"builtins.str*
@@ -114,29 +134,33 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 flags
 builtins.int"builtins.int *+
 regex
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
 repeat(pandas.core.strings.StringMethods.repeat"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 repeats
 1Union[builtins.int,typing.Sequence[builtins.int]]
 builtins.int"builtins.intN
 typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence*
+builtins.int"builtins.int"typing.Sequence*
 pad%pandas.core.strings.StringMethods.pad"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 width
 builtins.int"builtins.int*
@@ -149,65 +173,75 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str *,
 fillchar
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 center(pandas.core.strings.StringMethods.center"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 width
 builtins.int"builtins.int*,
 fillchar
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 ljust'pandas.core.strings.StringMethods.ljust"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 width
 builtins.int"builtins.int*,
 fillchar
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 rjust'pandas.core.strings.StringMethods.rjust"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 width
 builtins.int"builtins.int*,
 fillchar
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 zfill'pandas.core.strings.StringMethods.zfill"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 width
-builtins.int"builtins.int*
+builtins.int"builtins.int*
 slice'pandas.core.strings.StringMethods.slice"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*Q
 startD
 Union[builtins.int,None]
@@ -220,15 +254,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 stepD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None *
+None *
 
slice_replace/pandas.core.strings.StringMethods.slice_replace"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*Q
 startD
 Union[builtins.int,None]
@@ -241,80 +277,92 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 replD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *
+None *
 decode(pandas.core.strings.StringMethods.decode"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods**
 encoding
 builtins.str"builtins.str**
 errors
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 encode(pandas.core.strings.StringMethods.encode"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods**
 encoding
 builtins.str"builtins.str**
 errors
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 strip'pandas.core.strings.StringMethods.strip"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*T
 to_stripD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *
+None *
 lstrip(pandas.core.strings.StringMethods.lstrip"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*T
 to_stripD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *
+None *
 rstrip(pandas.core.strings.StringMethods.rstrip"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*T
 to_stripD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *
+None *
 wrap&pandas.core.strings.StringMethods.wrap"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 width
 builtins.int"builtins.int*Z
@@ -337,25 +385,29 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 break_on_hyphensG
 Union[builtins.bool,None]
 
builtins.bool"
builtins.bool
-None *
+None *
 get_dummies-pandas.core.strings.StringMethods.get_dummies":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 sep
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 	translate+pandas.core.strings.StringMethods.translate"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 table
 MUnion[builtins.dict[builtins.int,Union[builtins.int,builtins.str,None]],None]
@@ -365,29 +417,33 @@ Abuiltins.dict[builtins.int,Union[builtins.int,builtins.str,None]]
 builtins.int"builtins.int
 builtins.str"builtins.str
 None"
builtins.dict
-None*
+None*
 count'pandas.core.strings.StringMethods.count"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 pat
 builtins.str"builtins.str*)
 flags
-builtins.int"builtins.int *
+builtins.int"builtins.int *
 
 startswith,pandas.core.strings.StringMethods.startswith"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 pat
 0Union[builtins.str,builtins.tuple[builtins.str]]
@@ -395,15 +451,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 builtins.tuple[builtins.str]
 builtins.str"builtins.str"builtins.tuple*
 na
-Any *
+Any *
 endswith*pandas.core.strings.StringMethods.endswith"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 pat
 0Union[builtins.str,builtins.tuple[builtins.str]]
@@ -411,41 +469,47 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 builtins.tuple[builtins.str]
 builtins.str"builtins.str"builtins.tuple*
 na
-Any *
+Any *
 findall)pandas.core.strings.StringMethods.findall"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+Any"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 pat
 builtins.str"builtins.str*)
 flags
-builtins.int"builtins.int *
+builtins.int"builtins.int *
 
 extractall,pandas.core.strings.StringMethods.extractall":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 pat
 builtins.str"builtins.str*)
 flags
-builtins.int"builtins.int *
+builtins.int"builtins.int *
 find&pandas.core.strings.StringMethods.find"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sub
 builtins.str"builtins.str*)
@@ -454,15 +518,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 endD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None *
+None *
 rfind'pandas.core.strings.StringMethods.rfind"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sub
 builtins.str"builtins.str*)
@@ -471,15 +537,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 endD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None *
+None *
 	normalize+pandas.core.strings.StringMethods.normalize"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 form
 ^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
@@ -490,15 +558,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str*
+builtins.str"builtins.str*
 index'pandas.core.strings.StringMethods.index"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sub
 builtins.str"builtins.str*)
@@ -507,15 +577,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 endD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None *
+None *
 rindex(pandas.core.strings.StringMethods.rindex"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sub
 builtins.str"builtins.str*)
@@ -524,160 +596,194 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 endD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None *
+None *
 len%pandas.core.strings.StringMethods.len"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 lower'pandas.core.strings.StringMethods.lower"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 upper'pandas.core.strings.StringMethods.upper"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 title'pandas.core.strings.StringMethods.title"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 
 capitalize,pandas.core.strings.StringMethods.capitalize"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 swapcase*pandas.core.strings.StringMethods.swapcase"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 casefold*pandas.core.strings.StringMethods.casefold"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 isalnum)pandas.core.strings.StringMethods.isalnum"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 isalpha)pandas.core.strings.StringMethods.isalpha"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 isdigit)pandas.core.strings.StringMethods.isdigit"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 isspace)pandas.core.strings.StringMethods.isspace"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 islower)pandas.core.strings.StringMethods.islower"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 isupper)pandas.core.strings.StringMethods.isupper"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 istitle)pandas.core.strings.StringMethods.istitle"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 	isnumeric+pandas.core.strings.StringMethods.isnumeric"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 	isdecimal+pandas.core.strings.StringMethods.isdecimal"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
+builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 	fullmatch+pandas.core.strings.StringMethods.fullmatch"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 pat
 builtins.str"builtins.str**
@@ -686,37 +792,43 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 flags
 builtins.int"builtins.int *
 na
-Any *
+Any *
 removeprefix.pandas.core.strings.StringMethods.removeprefix"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*(
 prefix
-builtins.str"builtins.str*
+builtins.str"builtins.str*
 removesuffix.pandas.core.strings.StringMethods.removesuffix"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*(
 suffix
-builtins.str"builtins.str2
-cat%pandas.core.strings.StringMethods.cat
+builtins.str"builtins.str2
+cat%pandas.core.strings.StringMethods.cat
 cat%pandas.core.strings.StringMethods.cat"
-builtins.str"builtins.str*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.str"builtins.str*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sep
 builtins.str"builtins.str*R
@@ -734,14 +846,16 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.JoinHow 0:typing.overloadX
+builtins.str"builtins.str"pandas._typing.JoinHow 0:typing.overloadX
 cat%pandas.core.strings.StringMethods.cat"
-builtins.str"builtins.str*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.str"builtins.str*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 others
 None *%
@@ -761,15 +875,17 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.JoinHow 0:typing.overloadX
+builtins.str"builtins.str"pandas._typing.JoinHow 0:typing.overloadX
 cat%pandas.core.strings.StringMethods.cat"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*
 others
 Union[pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],pandas.core.frame.DataFrame,numpy.ndarray[Any,Any],builtins.list[Any]]D
@@ -799,17 +915,18 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.JoinHow 0:typing.overloadX2
-
-split'pandas.core.strings.StringMethods.split
+builtins.str"builtins.str"pandas._typing.JoinHow 0:typing.overloadX2
+split'pandas.core.strings.StringMethods.split
 split'pandas.core.strings.StringMethods.split"P
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 pat
 builtins.str"builtins.str *%
@@ -819,15 +936,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool*+
 regex
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 split'pandas.core.strings.StringMethods.split"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 pat
 builtins.str"builtins.str *%
@@ -836,17 +955,18 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 expand
 
builtins.bool"
builtins.bool *+
 regex
-
builtins.bool"
builtins.bool 0:typing.overloadX2
-
-rsplit(pandas.core.strings.StringMethods.rsplit
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+rsplit(pandas.core.strings.StringMethods.rsplit
 rsplit(pandas.core.strings.StringMethods.rsplit"P
 pandas.core.strings._TS"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 pat
 builtins.str"builtins.str *%
@@ -856,15 +976,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool*+
 regex
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 rsplit(pandas.core.strings.StringMethods.rsplit"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 pat
 builtins.str"builtins.str *%
@@ -873,143 +995,165 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 expand
 
builtins.bool"
builtins.bool *+
 regex
-
builtins.bool"
builtins.bool 0:typing.overloadX2
-	partition+pandas.core.strings.StringMethods.partition
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+	partition+pandas.core.strings.StringMethods.partition
 	partition+pandas.core.strings.StringMethods.partition":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 sep
-builtins.str"builtins.str 0:typing.overloadX
+builtins.str"builtins.str 0:typing.overloadX
 	partition+pandas.core.strings.StringMethods.partition":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*F
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX
+
builtins.bool"
builtins.bool0:typing.overloadX
 	partition+pandas.core.strings.StringMethods.partition":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sep
 builtins.str"builtins.str*F
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX
+
builtins.bool"
builtins.bool0:typing.overloadX
 	partition+pandas.core.strings.StringMethods.partition"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sep
 builtins.str"builtins.str*F
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX
+
builtins.bool"
builtins.bool0:typing.overloadX
 	partition+pandas.core.strings.StringMethods.partition"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*F
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX2
+
builtins.bool"
builtins.bool0:typing.overloadX2
 
-rpartition,pandas.core.strings.StringMethods.rpartition
+rpartition,pandas.core.strings.StringMethods.rpartition
 
 rpartition,pandas.core.strings.StringMethods.rpartition":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*'
 sep
-builtins.str"builtins.str 0:typing.overloadX
+builtins.str"builtins.str 0:typing.overloadX
 
 rpartition,pandas.core.strings.StringMethods.rpartition":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*F
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX
+
builtins.bool"
builtins.bool0:typing.overloadX
 
 rpartition,pandas.core.strings.StringMethods.rpartition":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sep
 builtins.str"builtins.str*F
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX
+
builtins.bool"
builtins.bool0:typing.overloadX
 
 rpartition,pandas.core.strings.StringMethods.rpartition"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 sep
 builtins.str"builtins.str*F
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX
+
builtins.bool"
builtins.bool0:typing.overloadX
 
 rpartition,pandas.core.strings.StringMethods.rpartition"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*F
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX2
-extract)pandas.core.strings.StringMethods.extract
+
builtins.bool"
builtins.bool0:typing.overloadX2
+extract)pandas.core.strings.StringMethods.extract
 extract)pandas.core.strings.StringMethods.extract":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 pat
 builtins.str"builtins.str*)
@@ -1017,15 +1161,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 builtins.int"builtins.int *H
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 extract)pandas.core.strings.StringMethods.extract"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 pat
 builtins.str"builtins.str*'
@@ -1033,15 +1179,17 @@ Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
 builtins.int"builtins.int*F
 expand:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX
+
builtins.bool"
builtins.bool0:typing.overloadX
 extract)pandas.core.strings.StringMethods.extract"I
 pandas._typing.T"
-builtins.object"builtins.object"builtins.object*
-self
-Kpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS]I
+builtins.object"builtins.object"builtins.object*
+self
+cpandas.core.strings.StringMethods[pandas._typing.T,pandas.core.strings._TS,pandas.core.strings._TM]I
 pandas._typing.T"
 builtins.object"builtins.object"builtins.objectP
 pandas.core.strings._TS"
+builtins.object"builtins.object"builtins.objectP
+pandas.core.strings._TM"
 builtins.object"builtins.object"builtins.object"!pandas.core.strings.StringMethods*%
 pat
 builtins.str"builtins.str*)
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.datetimes.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.datetimes.protobuf
index f4d27f3431..3d144f4201 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.datetimes.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.datetimes.protobuf
@@ -1,5 +1,5 @@
 
-pandas.core.tools.datetimes"\
+pandas.core.tools.datetimes"Z
 to_datetime'pandas.core.tools.datetimes.to_datetime
 to_datetime'pandas.core.tools.datetimes.to_datetime"T
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
@@ -110,7 +110,7 @@ eUnion[TypeAlias[Union[builtins.float,builtins.str]],datetime.datetime,numpy.dat
 builtins.float"builtins.float
 builtins.str"builtins.str"(pandas._typing.TimestampConvertibleTypes *+
 cache
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 to_datetime'pandas.core.tools.datetimes.to_datetime"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
 arg
@@ -121,16 +121,14 @@ BTypeAlias[Union[TypeAlias[TypedDict],pandas.core.frame.DataFrame]]
 7Union[TypeAlias[TypedDict],pandas.core.frame.DataFrame]H
 TypeAlias[TypedDict]
 	TypedDict"pandas._typing.FulldatetimeDict:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas._typing.DictConvertible*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas._typing.DictConvertible*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *.
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *.
 dayfirst
 
builtins.bool"
builtins.bool */
 	yearfirst
@@ -167,22 +165,24 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.float"builtins.float
 builtins.str"builtins.str"(pandas._typing.TimestampConvertibleTypes *+
 cache
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 to_datetime'pandas.core.tools.datetimes.to_datetime"Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-arg
-Union[typing.Sequence[Union[builtins.float,datetime.datetime]],builtins.list[builtins.str],builtins.tuple[Union[builtins.float,builtins.str,datetime.datetime]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.indexes.base.Index[Any],pandas.core.arrays.base.ExtensionArray]
-8typing.Sequence[Union[builtins.float,datetime.datetime]]u
-'Union[builtins.float,datetime.datetime] 
-builtins.float"builtins.float&
-datetime.datetime"datetime.datetime"typing.SequenceJ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+
+arg
+
+Union[typing.Sequence[Union[builtins.float,datetime.date]],builtins.list[builtins.str],builtins.tuple[Union[builtins.float,builtins.str,datetime.date]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.indexes.base.Index[Any],pandas.core.arrays.base.ExtensionArray]
+4typing.Sequence[Union[builtins.float,datetime.date]]i
+#Union[builtins.float,datetime.date] 
+builtins.float"builtins.float
+
datetime.date"
datetime.date"typing.SequenceJ
 builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-Dbuiltins.tuple[Union[builtins.float,builtins.str,datetime.datetime]]
-4Union[builtins.float,builtins.str,datetime.datetime] 
+builtins.str"builtins.str"
builtins.list
+@builtins.tuple[Union[builtins.float,builtins.str,datetime.date]]
+0Union[builtins.float,builtins.str,datetime.date] 
 builtins.float"builtins.float
-builtins.str"builtins.str&
-datetime.datetime"datetime.datetime"builtins.tuple
+builtins.str"builtins.str
+
datetime.date"
datetime.date"builtins.tuple
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
@@ -191,16 +191,14 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayN
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.IndexP
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *.
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *.
 dayfirst
 
builtins.bool"
builtins.bool */
 	yearfirst
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.numeric.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.numeric.protobuf
index b2a8376b7a..287e80cd6b 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.numeric.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.numeric.protobuf
@@ -1,5 +1,5 @@
 
-pandas.core.tools.numeric"\
+pandas.core.tools.numeric"5
 
 to_numeric$pandas.core.tools.numeric.to_numeric
 
@@ -52,72 +52,7 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX$
-
-to_numeric$pandas.core.tools.numeric.to_numeric"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-arg
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*C
-errors7
-Literal[builtins.str]	
-builtins.str"builtins.str*
-downcast
-nTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]]
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"#pandas.core.tools.numeric._Downcast *
-
dtype_backend
-tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.DtypeBackend
-/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
-$Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
 
 to_numeric$pandas.core.tools.numeric.to_numeric"
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -134,16 +69,14 @@ DUnion[builtins.list[Any],builtins.tuple[Any],numpy.ndarray[Any,Any]],
 Any"builtins.tuple9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"
numpy.ndarray*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *
 downcast
 nTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]]
 cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
@@ -166,23 +99,21 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
 
 to_numeric$pandas.core.tools.numeric.to_numeric"D
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series*M
 argD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"pandas.core.series.Series*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *
 downcast
 nTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]]
 cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.timedeltas.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.timedeltas.protobuf
index 8199bc1c60..b63656a362 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.timedeltas.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.tools.timedeltas.protobuf
@@ -1,37 +1,17 @@
 
-pandas.core.tools.timedeltas"ϝ
-to_timedelta)pandas.core.tools.timedeltas.to_timedelta1
+pandas.core.tools.timedeltas"|
+to_timedelta)pandas.core.tools.timedeltas.to_timedelta&
 to_timedelta)pandas.core.tools.timedeltas.to_timedelta"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
 arg
 5Union[builtins.str,builtins.float,datetime.timedelta]
 builtins.str"builtins.str 
 builtins.float"builtins.float(
-datetime.timedelta"datetime.timedelta*+
-unit+
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+datetime.timedelta"datetime.timedelta*!
+unit!
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -100,45 +80,23 @@
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str"3pandas._libs.tslibs.timedeltas.TimeDeltaUnitChoices
-None *
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce 0:typing.overloadX0
+builtins.str"builtins.str"pandas._typing.RaiseCoerce 0:typing.overloadX%
 to_timedelta)pandas.core.tools.timedeltas.to_timedelta"H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*M
 argD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*+
-unit+
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"pandas.core.series.Series*!
+unit!
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -207,29 +165,26 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str"3pandas._libs.tslibs.timedeltas.TimeDeltaUnitChoices
-None *
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce 0:typing.overloadX;
+builtins.str"builtins.str"pandas._typing.RaiseCoerce 0:typing.overloadX/
 to_timedelta)pandas.core.tools.timedeltas.to_timedelta"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-arg
-Union[typing.Sequence[Union[builtins.float,datetime.timedelta]],builtins.list[Union[builtins.str,builtins.float,datetime.timedelta]],builtins.tuple[Union[builtins.str,builtins.float,datetime.timedelta]],builtins.range,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.indexes.base.Index[Any]]
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+
+arg
+
+Union[pandas._typing.SequenceNotStr[Any],typing.Sequence[Union[builtins.float,datetime.timedelta]],builtins.tuple[Union[builtins.str,builtins.float,datetime.timedelta]],builtins.range,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.indexes.base.Index[Any]]L
+"pandas._typing.SequenceNotStr[Any]
+Any"pandas._typing.SequenceNotStr
 9typing.Sequence[Union[builtins.float,datetime.timedelta]]x
 (Union[builtins.float,datetime.timedelta] 
 builtins.float"builtins.float(
-datetime.timedelta"datetime.timedelta"typing.Sequence
-Dbuiltins.list[Union[builtins.str,builtins.float,datetime.timedelta]]
-5Union[builtins.str,builtins.float,datetime.timedelta]
-builtins.str"builtins.str 
-builtins.float"builtins.float(
-datetime.timedelta"datetime.timedelta"
builtins.list
+datetime.timedelta"datetime.timedelta"typing.Sequence
 Ebuiltins.tuple[Union[builtins.str,builtins.float,datetime.timedelta]]
 5Union[builtins.str,builtins.float,datetime.timedelta]
 builtins.str"builtins.str 
@@ -243,31 +198,11 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 Any
 Any"
numpy.ndarray"pandas._typing.ArrayLikeN
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*+
-unit+
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"pandas.core.indexes.base.Index*!
+unit!
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -336,16 +271,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str"3pandas._libs.tslibs.timedeltas.TimeDeltaUnitChoices
-None *
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce 0:typing.overloadX*
+builtins.str"builtins.str"pandas._typing.RaiseCoerce 0:typing.overloadX*
 __annotations__,pandas.core.tools.timedeltas.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.ewm.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.ewm.protobuf
index 8922c6543c..f5896de855 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.ewm.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.ewm.protobuf
@@ -1,80 +1,28 @@
 
-pandas.core.window.ewm_
-ExponentialMovingWindow.pandas.core.window.ewm.ExponentialMovingWindow"%pandas.core.window.rolling.BaseWindow*
-__init__7pandas.core.window.ewm.ExponentialMovingWindow.__init__"
-None*
+pandas.core.window.ewm.
+ExponentialMovingWindow.pandas.core.window.ewm.ExponentialMovingWindow"%pandas.core.window.rolling.BaseWindow*
+online5pandas.core.window.ewm.ExponentialMovingWindow.online"
+Mpandas.core.window.ewm.OnlineExponentialMovingWindow[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"4pandas.core.window.ewm.OnlineExponentialMovingWindow*
 self
 Gpandas.core.window.ewm.ExponentialMovingWindow[pandas._typing.NDFrameT]t
 pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame".pandas.core.window.ewm.ExponentialMovingWindow*}
-objt
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*U
-comJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *V
-spanJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-halflife
-Union[TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]],None]
-TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]]
-Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
-datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64
-4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
-)numpy.signedinteger[numpy._typing._64Bit],
-numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64 
-builtins.float"builtins.float
-builtins.str"builtins.str"(pandas._typing.TimedeltaConvertibleTypes
-None *W
-alphaJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *W
-min_periodsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *,
-adjust
-
builtins.bool"
builtins.bool */
-	ignore_na
-
builtins.bool"
builtins.bool *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-times
-`Union[builtins.str,numpy.ndarray[Any,Any],pandas.core.series.Series[Any],None,numpy.timedelta64]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None&
-numpy.timedelta64"numpy.timedelta64 *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame".pandas.core.window.ewm.ExponentialMovingWindow*
+engine
+BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod *
+builtins.str"builtins.str
+None"pandas._typing.WindowingEngine *
+
engine_kwargs
++TypeAlias[Union[TypeAlias[TypedDict],None]]}
+ Union[TypeAlias[TypedDict],None]M
+TypeAlias[TypedDict]
+	TypedDict"$pandas._typing._WindowingNumbaKwargs
+None"$pandas._typing.WindowingEngineKwargs *
 mean3pandas.core.window.ewm.ExponentialMovingWindow.mean"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
@@ -84,7 +32,7 @@ Gpandas.core.window.ewm.ExponentialMovingWindow[pandas._typing.NDFrameT]t
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame".pandas.core.window.ewm.ExponentialMovingWindow*2
 numeric_only
 
builtins.bool"
builtins.bool *
-engine
+engine
 BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
 7Union[Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
@@ -92,7 +40,7 @@ BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
 Literal[builtins.str]	
 builtins.str"builtins.str
 None"pandas._typing.WindowingEngine *
-
engine_kwargs
+
engine_kwargs
 +TypeAlias[Union[TypeAlias[TypedDict],None]]}
  Union[TypeAlias[TypedDict],None]M
 TypeAlias[TypedDict]
@@ -107,7 +55,7 @@ Gpandas.core.window.ewm.ExponentialMovingWindow[pandas._typing.NDFrameT]t
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame".pandas.core.window.ewm.ExponentialMovingWindow*2
 numeric_only
 
builtins.bool"
builtins.bool *
-engine
+engine
 BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
 7Union[Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
@@ -115,7 +63,7 @@ BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
 Literal[builtins.str]	
 builtins.str"builtins.str
 None"pandas._typing.WindowingEngine *
-
engine_kwargs
+
engine_kwargs
 +TypeAlias[Union[TypeAlias[TypedDict],None]]}
  Union[TypeAlias[TypedDict],None]M
 TypeAlias[TypedDict]
@@ -182,77 +130,100 @@ FUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any],None]:
 
builtins.bool"
builtins.bool
 None *2
 numeric_only
-
builtins.bool"
builtins.bool 2
-	aggregate8pandas.core.window.ewm.ExponentialMovingWindow.aggregate
-	aggregate8pandas.core.window.ewm.ExponentialMovingWindow.aggregate"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
+
builtins.bool"
builtins.bool P
+ExponentialMovingWindowGroupby5pandas.core.window.ewm.ExponentialMovingWindowGroupby",pandas.core.window.rolling.BaseWindowGroupby".pandas.core.window.ewm.ExponentialMovingWindowP
+OnlineExponentialMovingWindow4pandas.core.window.ewm.OnlineExponentialMovingWindow".pandas.core.window.ewm.ExponentialMovingWindow*
+reset:pandas.core.window.ewm.OnlineExponentialMovingWindow.reset"
+None*
+self
+Mpandas.core.window.ewm.OnlineExponentialMovingWindow[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"4pandas.core.window.ewm.OnlineExponentialMovingWindow*u
+	aggregate>pandas.core.window.ewm.OnlineExponentialMovingWindow.aggregate*
+self*
+func*
+args*
+
+kwargs*
+std8pandas.core.window.ewm.OnlineExponentialMovingWindow.std"
+Any*
+self
+Mpandas.core.window.ewm.OnlineExponentialMovingWindow[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"4pandas.core.window.ewm.OnlineExponentialMovingWindow**
+bias
+
builtins.bool"
builtins.bool *
 args
 Any*
 kwargs
-Any0:typing.overloadX
-	aggregate8pandas.core.window.ewm.ExponentialMovingWindow.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
+Any*
+corr9pandas.core.window.ewm.OnlineExponentialMovingWindow.corr"
+Any*
+self
+Mpandas.core.window.ewm.OnlineExponentialMovingWindow[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"4pandas.core.window.ewm.OnlineExponentialMovingWindow*
+other
+FUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any],None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
-func
-TypeAlias[Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]]
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
-0typing.Mapping[pandas._typing.HashableT,Unknown]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries"'pandas._typing.AggFuncTypeSeriesToFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate8pandas.core.window.ewm.ExponentialMovingWindow.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.window.ewm.ExponentialMovingWindow[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame".pandas.core.window.ewm.ExponentialMovingWindow*	
-func	
-TypeAlias[Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]]
-Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase)
-builtins.list[Unknown]"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame"pandas._typing.AggFuncTypeFrame*
+Any"pandas.core.series.Series
+None *W
+pairwiseG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+cov8pandas.core.window.ewm.OnlineExponentialMovingWindow.cov"
+Any*
+self
+Mpandas.core.window.ewm.OnlineExponentialMovingWindow[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"4pandas.core.window.ewm.OnlineExponentialMovingWindow*
+other
+FUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any],None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None *W
+pairwiseG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None **
+bias
+
builtins.bool"
builtins.bool *2
+numeric_only
+
builtins.bool"
builtins.bool *
+var8pandas.core.window.ewm.OnlineExponentialMovingWindow.var"
+Any*
+self
+Mpandas.core.window.ewm.OnlineExponentialMovingWindow[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"4pandas.core.window.ewm.OnlineExponentialMovingWindow**
+bias
+
builtins.bool"
builtins.bool *2
+numeric_only
+
builtins.bool"
builtins.bool *
+mean9pandas.core.window.ewm.OnlineExponentialMovingWindow.mean"t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
+self
+Mpandas.core.window.ewm.OnlineExponentialMovingWindow[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"4pandas.core.window.ewm.OnlineExponentialMovingWindow*
 args
-Any*
+Any*
+update
+#Union[pandas._typing.NDFrameT,None]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame
+None *
+update_times
+None *
 kwargs
-Any0:typing.overloadXP*
+AnyP*
 __annotations__&pandas.core.window.ewm.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict*
-npnumpy 
\ No newline at end of file
+Any"
builtins.dict
\ No newline at end of file
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.expanding.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.expanding.protobuf
index 74546a18d9..d8464cef6e 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.expanding.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.expanding.protobuf
@@ -1,402 +1,7 @@
 
-pandas.core.window.expanding
-	Expanding&pandas.core.window.expanding.Expanding"3pandas.core.window.rolling.RollingAndExpandingMixin*
-count,pandas.core.window.expanding.Expanding.count"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*
-
-apply,pandas.core.window.expanding.Expanding.apply"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *i
-args]
-Union[builtins.tuple[Any],None].
-builtins.tuple[Any]
-Any"builtins.tuple
-None *
-kwargs
-+Union[builtins.dict[builtins.str,Any],None]W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict
-None *
-sum*pandas.core.window.expanding.Expanding.sum"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-max*pandas.core.window.expanding.Expanding.max"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-min*pandas.core.window.expanding.Expanding.min"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-mean+pandas.core.window.expanding.Expanding.mean"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-median-pandas.core.window.expanding.Expanding.median"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-std*pandas.core.window.expanding.Expanding.std"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-var*pandas.core.window.expanding.Expanding.var"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-sem*pandas.core.window.expanding.Expanding.sem"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-skew+pandas.core.window.expanding.Expanding.skew"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-kurt+pandas.core.window.expanding.Expanding.kurt"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-quantile/pandas.core.window.expanding.Expanding.quantile"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*.
-quantile 
-builtins.float"builtins.float*
-
interpolation
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *2
-numeric_only
-
builtins.bool"
builtins.bool *
-rank+pandas.core.window.expanding.Expanding.rank"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.WindowingRankType */
-	ascending
-
builtins.bool"
builtins.bool *)
-pct
-
builtins.bool"
builtins.bool *2
-numeric_only
-
builtins.bool"
builtins.bool *
-cov*pandas.core.window.expanding.Expanding.cov"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*
-other
-FUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any],None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None *W
-pairwiseG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-corr+pandas.core.window.expanding.Expanding.corr"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*
-other
-FUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any],None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None *W
-pairwiseG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool 2
-	aggregate0pandas.core.window.expanding.Expanding.aggregate
-	aggregate0pandas.core.window.expanding.Expanding.aggregate"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate0pandas.core.window.expanding.Expanding.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
-func
-TypeAlias[Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]]
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
-0typing.Mapping[pandas._typing.HashableT,Unknown]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries"'pandas._typing.AggFuncTypeSeriesToFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate0pandas.core.window.expanding.Expanding.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Cpandas.core.window.expanding.Expanding[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"&pandas.core.window.expanding.Expanding*	
-func	
-TypeAlias[Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]]
-Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase)
-builtins.list[Unknown]"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame"pandas._typing.AggFuncTypeFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadXP
-ExpandingGroupby-pandas.core.window.expanding.ExpandingGroupby",pandas.core.window.rolling.BaseWindowGroupby"&pandas.core.window.expanding.Expanding*
+pandas.core.window.expandingj
+	Expanding&pandas.core.window.expanding.Expanding"3pandas.core.window.rolling.RollingAndExpandingMixinP
+ExpandingGroupby-pandas.core.window.expanding.ExpandingGroupby",pandas.core.window.rolling.BaseWindowGroupby"&pandas.core.window.expanding.ExpandingP*
 __annotations__,pandas.core.window.expanding.__annotations__W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.protobuf
index d971dde6e8..ebea709885 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.protobuf
@@ -1,80 +1,28 @@
 
-pandas.core.window_
-ExponentialMovingWindow.pandas.core.window.ewm.ExponentialMovingWindow"%pandas.core.window.rolling.BaseWindow*
-__init__7pandas.core.window.ewm.ExponentialMovingWindow.__init__"
-None*
+pandas.core.window.
+ExponentialMovingWindow.pandas.core.window.ewm.ExponentialMovingWindow"%pandas.core.window.rolling.BaseWindow*
+online5pandas.core.window.ewm.ExponentialMovingWindow.online"
+Mpandas.core.window.ewm.OnlineExponentialMovingWindow[pandas._typing.NDFrameT]t
+pandas._typing.NDFrameT:
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"4pandas.core.window.ewm.OnlineExponentialMovingWindow*
 self
 Gpandas.core.window.ewm.ExponentialMovingWindow[pandas._typing.NDFrameT]t
 pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame".pandas.core.window.ewm.ExponentialMovingWindow*}
-objt
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*U
-comJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *V
-spanJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-halflife
-Union[TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]],None]
-TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]]
-Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.float,builtins.str]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
-datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64
-4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
-)numpy.signedinteger[numpy._typing._64Bit],
-numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64 
-builtins.float"builtins.float
-builtins.str"builtins.str"(pandas._typing.TimedeltaConvertibleTypes
-None *W
-alphaJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *W
-min_periodsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *,
-adjust
-
builtins.bool"
builtins.bool */
-	ignore_na
-
builtins.bool"
builtins.bool *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-times
-`Union[builtins.str,numpy.ndarray[Any,Any],pandas.core.series.Series[Any],None,numpy.timedelta64]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None&
-numpy.timedelta64"numpy.timedelta64 *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame".pandas.core.window.ewm.ExponentialMovingWindow*
+engine
+BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod *
+builtins.str"builtins.str
+None"pandas._typing.WindowingEngine *
+
engine_kwargs
++TypeAlias[Union[TypeAlias[TypedDict],None]]}
+ Union[TypeAlias[TypedDict],None]M
+TypeAlias[TypedDict]
+	TypedDict"$pandas._typing._WindowingNumbaKwargs
+None"$pandas._typing.WindowingEngineKwargs *
 mean3pandas.core.window.ewm.ExponentialMovingWindow.mean"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
@@ -84,7 +32,7 @@ Gpandas.core.window.ewm.ExponentialMovingWindow[pandas._typing.NDFrameT]t
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame".pandas.core.window.ewm.ExponentialMovingWindow*2
 numeric_only
 
builtins.bool"
builtins.bool *
-engine
+engine
 BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
 7Union[Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
@@ -92,7 +40,7 @@ BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
 Literal[builtins.str]	
 builtins.str"builtins.str
 None"pandas._typing.WindowingEngine *
-
engine_kwargs
+
engine_kwargs
 +TypeAlias[Union[TypeAlias[TypedDict],None]]}
  Union[TypeAlias[TypedDict],None]M
 TypeAlias[TypedDict]
@@ -107,7 +55,7 @@ Gpandas.core.window.ewm.ExponentialMovingWindow[pandas._typing.NDFrameT]t
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame".pandas.core.window.ewm.ExponentialMovingWindow*2
 numeric_only
 
builtins.bool"
builtins.bool *
-engine
+engine
 BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
 7Union[Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
@@ -115,7 +63,7 @@ BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
 Literal[builtins.str]	
 builtins.str"builtins.str
 None"pandas._typing.WindowingEngine *
-
engine_kwargs
+
engine_kwargs
 +TypeAlias[Union[TypeAlias[TypedDict],None]]}
  Union[TypeAlias[TypedDict],None]M
 TypeAlias[TypedDict]
@@ -182,581 +130,12 @@ FUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any],None]:
 
builtins.bool"
builtins.bool
 None *2
 numeric_only
-
builtins.bool"
builtins.bool 2
-	aggregate8pandas.core.window.ewm.ExponentialMovingWindow.aggregate
-	aggregate8pandas.core.window.ewm.ExponentialMovingWindow.aggregate"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate8pandas.core.window.ewm.ExponentialMovingWindow.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
-func
-TypeAlias[Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]]
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
-0typing.Mapping[pandas._typing.HashableT,Unknown]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries"'pandas._typing.AggFuncTypeSeriesToFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate8pandas.core.window.ewm.ExponentialMovingWindow.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Kpandas.core.window.ewm.ExponentialMovingWindow[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame".pandas.core.window.ewm.ExponentialMovingWindow*	
-func	
-TypeAlias[Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]]
-Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase)
-builtins.list[Unknown]"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame"pandas._typing.AggFuncTypeFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadXP
-	Expanding&pandas.core.window.expanding.Expanding"3pandas.core.window.rolling.RollingAndExpandingMixin*
-count,pandas.core.window.expanding.Expanding.count"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*
-
-apply,pandas.core.window.expanding.Expanding.apply"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *i
-args]
-Union[builtins.tuple[Any],None].
-builtins.tuple[Any]
-Any"builtins.tuple
-None *
-kwargs
-+Union[builtins.dict[builtins.str,Any],None]W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict
-None *
-sum*pandas.core.window.expanding.Expanding.sum"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-max*pandas.core.window.expanding.Expanding.max"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-min*pandas.core.window.expanding.Expanding.min"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-mean+pandas.core.window.expanding.Expanding.mean"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-median-pandas.core.window.expanding.Expanding.median"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-std*pandas.core.window.expanding.Expanding.std"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-var*pandas.core.window.expanding.Expanding.var"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs *
-sem*pandas.core.window.expanding.Expanding.sem"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-skew+pandas.core.window.expanding.Expanding.skew"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-kurt+pandas.core.window.expanding.Expanding.kurt"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*2
-numeric_only
-
builtins.bool"
builtins.bool *
-quantile/pandas.core.window.expanding.Expanding.quantile"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*.
-quantile 
-builtins.float"builtins.float*
-
interpolation
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *2
-numeric_only
-
builtins.bool"
builtins.bool *
-rank+pandas.core.window.expanding.Expanding.rank"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.WindowingRankType */
-	ascending
-
builtins.bool"
builtins.bool *)
-pct
-
builtins.bool"
builtins.bool *2
-numeric_only
-
builtins.bool"
builtins.bool *
-cov*pandas.core.window.expanding.Expanding.cov"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*
-other
-FUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any],None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None *W
-pairwiseG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool *
-corr+pandas.core.window.expanding.Expanding.corr"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-?pandas.core.window.expanding.Expanding[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"&pandas.core.window.expanding.Expanding*
-other
-FUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any],None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None *W
-pairwiseG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *(
-ddof
-builtins.int"builtins.int *2
-numeric_only
-
builtins.bool"
builtins.bool 2
-	aggregate0pandas.core.window.expanding.Expanding.aggregate
-	aggregate0pandas.core.window.expanding.Expanding.aggregate"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate0pandas.core.window.expanding.Expanding.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
-func
-TypeAlias[Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]]
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
-0typing.Mapping[pandas._typing.HashableT,Unknown]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries"'pandas._typing.AggFuncTypeSeriesToFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate0pandas.core.window.expanding.Expanding.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Cpandas.core.window.expanding.Expanding[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"&pandas.core.window.expanding.Expanding*	
-func	
-TypeAlias[Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]]
-Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase)
-builtins.list[Unknown]"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame"pandas._typing.AggFuncTypeFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadXP
-ExpandingGroupby-pandas.core.window.expanding.ExpandingGroupby",pandas.core.window.rolling.BaseWindowGroupby"&pandas.core.window.expanding.Expanding)
-Rolling"pandas.core.window.rolling.Rolling"3pandas.core.window.rolling.RollingAndExpandingMixin*
-apply(pandas.core.window.rolling.Rolling.apply"t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
-self
-;pandas.core.window.rolling.Rolling[pandas._typing.NDFrameT]t
-pandas._typing.NDFrameT:
-pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame""pandas.core.window.rolling.Rolling*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-engine
-BTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],None]]
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"pandas._typing.WindowingEngine *
-
engine_kwargs
-7Union[TypeAlias[Union[TypeAlias[TypedDict],None]],None]
-+TypeAlias[Union[TypeAlias[TypedDict],None]]}
- Union[TypeAlias[TypedDict],None]M
-TypeAlias[TypedDict]
-	TypedDict"$pandas._typing._WindowingNumbaKwargs
-None"$pandas._typing.WindowingEngineKwargs
-None *i
-args]
-Union[builtins.tuple[Any],None].
-builtins.tuple[Any]
-Any"builtins.tuple
-None *
-kwargs
-+Union[builtins.dict[builtins.str,Any],None]W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict
-None 2
-	aggregate,pandas.core.window.rolling.Rolling.aggregate
-	aggregate,pandas.core.window.rolling.Rolling.aggregate"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-Bpandas.core.window.rolling.Rolling[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series""pandas.core.window.rolling.Rolling*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate,pandas.core.window.rolling.Rolling.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Bpandas.core.window.rolling.Rolling[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series""pandas.core.window.rolling.Rolling*
-func
-TypeAlias[Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]]
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
-0typing.Mapping[pandas._typing.HashableT,Unknown]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries"'pandas._typing.AggFuncTypeSeriesToFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate,pandas.core.window.rolling.Rolling.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-?pandas.core.window.rolling.Rolling[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame""pandas.core.window.rolling.Rolling*	
-func	
-TypeAlias[Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]]
-Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase)
-builtins.list[Unknown]"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame"pandas._typing.AggFuncTypeFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadXP
-RollingGroupby)pandas.core.window.rolling.RollingGroupby",pandas.core.window.rolling.BaseWindowGroupby""pandas.core.window.rolling.RollingP-
+
builtins.bool"
builtins.bool P
+ExponentialMovingWindowGroupby5pandas.core.window.ewm.ExponentialMovingWindowGroupby",pandas.core.window.rolling.BaseWindowGroupby".pandas.core.window.ewm.ExponentialMovingWindowPj
+	Expanding&pandas.core.window.expanding.Expanding"3pandas.core.window.rolling.RollingAndExpandingMixinP
+ExpandingGroupby-pandas.core.window.expanding.ExpandingGroupby",pandas.core.window.rolling.BaseWindowGroupby"&pandas.core.window.expanding.ExpandingPd
+Rolling"pandas.core.window.rolling.Rolling"3pandas.core.window.rolling.RollingAndExpandingMixinP
+RollingGroupby)pandas.core.window.rolling.RollingGroupby",pandas.core.window.rolling.BaseWindowGroupby""pandas.core.window.rolling.RollingP
 Window!pandas.core.window.rolling.Window"%pandas.core.window.rolling.BaseWindow*
 sum%pandas.core.window.rolling.Window.sum"t
 pandas._typing.NDFrameT:
@@ -779,7 +158,7 @@ Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]
 numeric_only
 
builtins.bool"
builtins.bool *
 kwargs
-Any*
+Any*
 var%pandas.core.window.rolling.Window.var"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
@@ -790,11 +169,9 @@ Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]
 ddof
 builtins.int"builtins.int *2
 numeric_only
-
builtins.bool"
builtins.bool *
-args
-Any*
+
builtins.bool"
builtins.bool *
 kwargs
-Any*
+Any*
 std%pandas.core.window.rolling.Window.std"t
 pandas._typing.NDFrameT:
 pandas.core.generic.NDFrame"pandas.core.generic.NDFrame"pandas.core.generic.NDFrame*
@@ -805,79 +182,9 @@ Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]
 ddof
 builtins.int"builtins.int *2
 numeric_only
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any2
-	aggregate+pandas.core.window.rolling.Window.aggregate
-	aggregate+pandas.core.window.rolling.Window.aggregate"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-Apandas.core.window.rolling.Window[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"!pandas.core.window.rolling.Window*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate+pandas.core.window.rolling.Window.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-Apandas.core.window.rolling.Window[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"!pandas.core.window.rolling.Window*
-func
-TypeAlias[Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]]
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
-0typing.Mapping[pandas._typing.HashableT,Unknown]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries"'pandas._typing.AggFuncTypeSeriesToFrame*
-args
-Any*
-kwargs
-Any0:typing.overloadX
-	aggregate+pandas.core.window.rolling.Window.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
->pandas.core.window.rolling.Window[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"!pandas.core.window.rolling.Window*	
-func	
-TypeAlias[Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]]
-Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],builtins.list[Unknown],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase)
-builtins.list[Unknown]"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame"pandas._typing.AggFuncTypeFrame*
-args
-Any*
+
builtins.bool"
builtins.bool *
 kwargs
-Any0:typing.overloadXP*s
+AnyP*s
 __path__pandas.core.window.__path__J
 builtins.list[builtins.str]
 builtins.str"builtins.str"
builtins.list*
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.rolling.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.rolling.protobuf
index 8ef43f5b82..73f2f747c7 100644
Binary files a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.rolling.protobuf and b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.core.window.rolling.protobuf differ
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.io.api.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.io.api.protobuf
index f127e7989c..89c137a661 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.io.api.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.io.api.protobuf
@@ -1,5 +1,5 @@
 
-
pandas.io.api
+
pandas.io.api
 	ExcelFilepandas.io.excel._base.ExcelFile"builtins.object*
 
 __init__(pandas.io.excel._base.ExcelFile.__init__"
@@ -76,8 +76,8 @@ $pandas.io.excel._base.ExcelFile.SelfB
 None*
 __del__'pandas.io.excel._base.ExcelFile.__del__"
 None*DB
-pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile2d
-parse%pandas.io.excel._base.ExcelFile.parse3
+pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile2e
+parse%pandas.io.excel._base.ExcelFile.parse3
 parse%pandas.io.excel._base.ExcelFile.parse"
 Kbuiltins.dict[Union[builtins.int,builtins.str],pandas.core.frame.DataFrame]`
  Union[builtins.int,builtins.str]
@@ -120,27 +120,24 @@ sheet_name
 builtins.int"builtins.intN
 typing.Sequence[builtins.int]
 builtins.int"builtins.int"typing.Sequence
-None *
-
-usecols
-
-Union[builtins.str,TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]]
-builtins.str"builtins.str
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -225,7 +222,7 @@ skipfooter
 	na_filter
 
builtins.bool"
builtins.bool *
 kwds
-Any0:typing.overloadX0
+Any0:typing.overloadX1
 parse%pandas.io.excel._base.ExcelFile.parse":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*L
 selfB
@@ -261,27 +258,24 @@ sheet_name`
 builtins.int"builtins.intN
 typing.Sequence[builtins.int]
 builtins.int"builtins.int"typing.Sequence
-None *
-
-usecols
-
-Union[builtins.str,TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]]
-builtins.str"builtins.str
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -378,8 +372,8 @@ xUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.R
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
 )pandas._typing.ReadBuffer[builtins.bytes] 
 builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer 
-builtins.bytes"builtins.bytes*
-ExcelWriter!pandas.io.excel._base.ExcelWriter"builtins.object*
+builtins.bytes"builtins.bytes-
+ExcelWriter!pandas.io.excel._base.ExcelWriter"builtins.object*
 __init__*pandas.io.excel._base.ExcelWriter.__init__"
 None*P
 selfF
@@ -392,15 +386,17 @@ xUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.R
 os.PathLike[builtins.str]
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathB
 pandas._typing.WriteExcelBuffer"pandas._typing.WriteExcelBufferF
-!pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter*
-engine
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+!pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter*
+engine
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],None]
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.ExcelWriteEngine7
 Literal[builtins.str]	
 builtins.str"builtins.str
 None *W
@@ -446,15 +442,16 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 builtins.tuple[builtins.str]
 builtins.str"builtins.str"builtins.tuple*P
 selfF
-!pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter0:builtins.property`*
-engine(pandas.io.excel._base.ExcelWriter.engine"
+!pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter0:builtins.property`*
+engine(pandas.io.excel._base.ExcelWriter.engine"
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
 HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str*P
+builtins.str"builtins.str"pandas._typing.ExcelWriteEngine*P
 selfF
 !pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter0:builtins.property`*
 sheets(pandas.io.excel._base.ExcelWriter.sheets"W
@@ -1066,7 +1063,7 @@ MUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str
-None +
+None 0
 	read_htmlpandas.io.html.read_html"w
 *builtins.list[pandas.core.frame.DataFrame]:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.list*
@@ -1084,10 +1081,18 @@ gUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.R
 builtins.str"builtins.str&
 re.Pattern[Any]
 Any"
-re.Pattern *R
-flavorD
-Union[builtins.str,None]
-builtins.str"builtins.str
+re.Pattern *
+flavor
+xUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],typing.Sequence[Unknown],None]
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.HTMLFlavors-
+typing.Sequence[Unknown]"typing.Sequence
 None *
 header
 6Union[builtins.int,typing.Sequence[builtins.int],None]
@@ -1196,7 +1201,14 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions 
 read_orcpandas.io.orc.read_orc":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 path
@@ -1517,8 +1529,8 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault "
-read_clipboard#pandas.io.clipboards.read_clipboardb
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault "Ȭ
+read_clipboard#pandas.io.clipboards.read_clipboardd
 read_clipboard#pandas.io.clipboards.read_clipboard"T
 (pandas.io.parsers.readers.TextFileReader"(pandas.io.parsers.readers.TextFileReader*O
 sepD
@@ -1573,23 +1585,22 @@ nUnion[builtins.int,builtins.str,typing.Sequence[Union[builtins.str,builtins.int
 builtins.int"builtins.int"typing.Sequence:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
-None *
-usecols
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *	
+usecols	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -1741,8 +1752,9 @@ skipfooter
 builtins.str"builtins.str
 None *-
 	quotechar
-builtins.str"builtins.str *
-quoting
+builtins.str"builtins.str *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -1752,7 +1764,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *1
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *1
 doublequote
 
builtins.bool"
builtins.bool *V
 
@@ -1811,7 +1823,7 @@ BUnion[TypeAlias[Union[builtins.dict[builtins.str,Any],None]],None]
 builtins.str"builtins.str
 Any"
builtins.dict
 None"pandas._typing.StorageOptions
-None 0:typing.overloadXa
+None 0:typing.overloadXc
 read_clipboard#pandas.io.clipboards.read_clipboard"T
 (pandas.io.parsers.readers.TextFileReader"(pandas.io.parsers.readers.TextFileReader*O
 sepD
@@ -1866,23 +1878,22 @@ nUnion[builtins.int,builtins.str,typing.Sequence[Union[builtins.str,builtins.int
 builtins.int"builtins.int"typing.Sequence:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
-None *
-usecols
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *	
+usecols	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -2031,8 +2042,9 @@ skipfooter
 builtins.str"builtins.str
 None *-
 	quotechar
-builtins.str"builtins.str *
-quoting
+builtins.str"builtins.str *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -2042,7 +2054,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *1
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *1
 doublequote
 
builtins.bool"
builtins.bool *V
 
@@ -2101,7 +2113,7 @@ BUnion[TypeAlias[Union[builtins.dict[builtins.str,Any],None]],None]
 builtins.str"builtins.str
 Any"
builtins.dict
 None"pandas._typing.StorageOptions
-None 0:typing.overloadXa
+None 0:typing.overloadXc
 read_clipboard#pandas.io.clipboards.read_clipboard":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*O
 sepD
@@ -2156,23 +2168,22 @@ nUnion[builtins.int,builtins.str,typing.Sequence[Union[builtins.str,builtins.int
 builtins.int"builtins.int"typing.Sequence:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
-None *
-usecols
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *	
+usecols	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -2322,8 +2333,9 @@ skipfooter
 builtins.str"builtins.str
 None *-
 	quotechar
-builtins.str"builtins.str *
-quoting
+builtins.str"builtins.str *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -2333,7 +2345,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *1
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *1
 doublequote
 
builtins.bool"
builtins.bool *V
 
@@ -2392,39 +2404,465 @@ BUnion[TypeAlias[Union[builtins.dict[builtins.str,Any],None]],None]
 builtins.str"builtins.str
 Any"
builtins.dict
 None"pandas._typing.StorageOptions
-None 0:typing.overloadX"
+None 0:typing.overloadX"
+
+read_excel pandas.io.excel._base.read_excelR
+
+read_excel pandas.io.excel._base.read_excel"
+Abuiltins.dict[pandas._typing.IntStrT,pandas.core.frame.DataFrame]O
+pandas._typing.IntStrT"
+builtins.object"builtins.object"builtins.object:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.dict*
+io
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
+)pandas._typing.ReadBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.ReadBufferB
+pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile
+Any
+Any
+Any
+Any*
+
+sheet_name
+%builtins.list[pandas._typing.IntStrT]O
+pandas._typing.IntStrT"
+builtins.object"builtins.object"builtins.object"
builtins.list*
+header
+6Union[builtins.int,typing.Sequence[builtins.int],None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+None *
+names
+Union[TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]],None]
+TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]]
+Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]
+0typing.MutableSequence[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.MutableSequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
+builtins.range"builtins.range"pandas._typing.ListLikeHashable
+None *
+	index_col
+CUnion[builtins.int,typing.Sequence[builtins.int],builtins.str,None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+builtins.str"builtins.str
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None"pandas._typing.UsecolsArgType *
+dtype
+Union[builtins.str,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[builtins.str,Union[builtins.str,Unknown]],None]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype
+8typing.Mapping[builtins.str,Union[builtins.str,Unknown]]
+builtins.str"builtins.str?
+Union[builtins.str,Unknown]
+builtins.str"builtins.str"typing.Mapping
+None *
+engine
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ExcelReadEngine
+None *
+
+converters
+\Union[typing.Mapping[Union[builtins.int,builtins.str],CallableType[builtins.function]],None]
+Ptyping.Mapping[Union[builtins.int,builtins.str],CallableType[builtins.function]]`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"typing.Mapping
+None *
+true_values
+,Union[typing.Iterable[typing.Hashable],None]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable
+None *
+false_values
+,Union[typing.Iterable[typing.Hashable],None]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable
+None *
+skiprows
+VUnion[builtins.int,typing.Sequence[builtins.int],CallableType[builtins.function],None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *Q
+nrowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+	na_values
+rUnion[typing.Sequence[builtins.str],builtins.dict[Union[builtins.str,builtins.int],typing.Sequence[builtins.str]]]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+Mbuiltins.dict[Union[builtins.str,builtins.int],typing.Sequence[builtins.str]]`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.intN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence"
builtins.dict *5
+keep_default_na
+
builtins.bool"
builtins.bool */
+	na_filter
+
builtins.bool"
builtins.bool *-
+verbose
+
builtins.bool"
builtins.bool *
+parse_dates
+Union[builtins.bool,typing.Sequence[builtins.int],typing.Sequence[Union[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]],builtins.dict[builtins.str,Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]]]
+
builtins.bool"
builtins.boolN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+Styping.Sequence[Union[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]]
+BUnion[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.SequenceN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence"typing.Sequence
+\builtins.dict[builtins.str,Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]]
+builtins.str"builtins.str
+@Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]N
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list"
builtins.dict *
+date_format
+DUnion[builtins.dict[typing.Hashable,builtins.str],builtins.str,None]~
++builtins.dict[typing.Hashable,builtins.str]"
+typing.Hashable"typing.Hashable
+builtins.str"builtins.str"
builtins.dict
+builtins.str"builtins.str
+None *U
+	thousandsD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *+
+decimal
+builtins.str"builtins.str *S
+commentD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *.
+
+skipfooter
+builtins.int"builtins.int *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions *
+
dtype_backend
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.DtypeBackend
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXQ
+
+read_excel pandas.io.excel._base.read_excel"
+7builtins.dict[builtins.str,pandas.core.frame.DataFrame]
+builtins.str"builtins.str:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.dict*
+io
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
+)pandas._typing.ReadBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.ReadBufferB
+pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile
+Any
+Any
+Any
+Any*
+
+sheet_name
+None*
+header
+6Union[builtins.int,typing.Sequence[builtins.int],None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+None *
+names
+Union[TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]],None]
+TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]]
+Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]
+0typing.MutableSequence[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.MutableSequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
+builtins.range"builtins.range"pandas._typing.ListLikeHashable
+None *
+	index_col
+CUnion[builtins.int,typing.Sequence[builtins.int],builtins.str,None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+builtins.str"builtins.str
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None"pandas._typing.UsecolsArgType *
+dtype
+Union[builtins.str,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[builtins.str,Union[builtins.str,Unknown]],None]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype
+8typing.Mapping[builtins.str,Union[builtins.str,Unknown]]
+builtins.str"builtins.str?
+Union[builtins.str,Unknown]
+builtins.str"builtins.str"typing.Mapping
+None *
+engine
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ExcelReadEngine
+None *
+
+converters
+\Union[typing.Mapping[Union[builtins.int,builtins.str],CallableType[builtins.function]],None]
+Ptyping.Mapping[Union[builtins.int,builtins.str],CallableType[builtins.function]]`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"typing.Mapping
+None *
+true_values
+,Union[typing.Iterable[typing.Hashable],None]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable
+None *
+false_values
+,Union[typing.Iterable[typing.Hashable],None]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable
+None *
+skiprows
+VUnion[builtins.int,typing.Sequence[builtins.int],CallableType[builtins.function],None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *Q
+nrowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+	na_values
+rUnion[typing.Sequence[builtins.str],builtins.dict[Union[builtins.str,builtins.int],typing.Sequence[builtins.str]]]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+Mbuiltins.dict[Union[builtins.str,builtins.int],typing.Sequence[builtins.str]]`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.intN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence"
builtins.dict *5
+keep_default_na
+
builtins.bool"
builtins.bool */
+	na_filter
+
builtins.bool"
builtins.bool *-
+verbose
+
builtins.bool"
builtins.bool *
+parse_dates
+Union[builtins.bool,typing.Sequence[builtins.int],typing.Sequence[Union[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]],builtins.dict[builtins.str,Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]]]
+
builtins.bool"
builtins.boolN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+Styping.Sequence[Union[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]]
+BUnion[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.SequenceN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence"typing.Sequence
+\builtins.dict[builtins.str,Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]]
+builtins.str"builtins.str
+@Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]N
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list"
builtins.dict *
+date_format
+DUnion[builtins.dict[typing.Hashable,builtins.str],builtins.str,None]~
++builtins.dict[typing.Hashable,builtins.str]"
+typing.Hashable"typing.Hashable
+builtins.str"builtins.str"
builtins.dict
+builtins.str"builtins.str
+None *U
+	thousandsD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *+
+decimal
+builtins.str"builtins.str *S
+commentD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *.
 
-read_excel pandas.io.excel._base.read_excelO
+skipfooter
+builtins.int"builtins.int *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions *
+
dtype_backend
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.DtypeBackend
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXS
 
 read_excel pandas.io.excel._base.read_excel"
 Kbuiltins.dict[Union[builtins.int,builtins.str],pandas.core.frame.DataFrame]`
  Union[builtins.int,builtins.str]
 builtins.int"builtins.int
 builtins.str"builtins.str:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.dict*
-io
-Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],builtins.bytes,pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.dict*
+io
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
 8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
 -Union[builtins.str,os.PathLike[builtins.str]]
 builtins.str"builtins.strF
 os.PathLike[builtins.str]
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
 )pandas._typing.ReadBuffer[builtins.bytes] 
-builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer 
-builtins.bytes"builtins.bytesB
+builtins.bytes"builtins.bytes"pandas._typing.ReadBufferB
 pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile
 Any
 Any
 Any
-Any*
+Any*
 
-sheet_name
-;Union[builtins.list[Union[builtins.int,builtins.str]],None]
+sheet_name
 /builtins.list[Union[builtins.int,builtins.str]]`
  Union[builtins.int,builtins.str]
 builtins.int"builtins.int
-builtins.str"builtins.str"
builtins.list
-None*
+builtins.str"builtins.str"
builtins.list*
 header
 6Union[builtins.int,typing.Sequence[builtins.int],None]
 builtins.int"builtins.intN
@@ -2445,33 +2883,31 @@ sheet_name
 pandas._typing.HashableT"
 typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
 builtins.range"builtins.range"pandas._typing.ListLikeHashable
-None *
-	index_col
-6Union[builtins.int,typing.Sequence[builtins.int],None]
+None *
+	index_col
+CUnion[builtins.int,typing.Sequence[builtins.int],builtins.str,None]
 builtins.int"builtins.intN
 typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
-None *
-
-usecols
-
-Union[builtins.str,TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]]
-builtins.str"builtins.str
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+builtins.int"builtins.int"typing.Sequence
+builtins.str"builtins.str
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -2498,9 +2934,11 @@ $typing.MutableSequence[builtins.str]
 builtins.str"builtins.str?
 Union[builtins.str,Unknown]
 builtins.str"builtins.str"typing.Mapping
-None *
-engine
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+None *
+engine
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -2508,7 +2946,9 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ExcelReadEngine
 None *
 
 converters
@@ -2613,20 +3053,19 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXM
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXQ
 
 read_excel pandas.io.excel._base.read_excel":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-io
-Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],builtins.bytes,pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+io
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
 8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
 -Union[builtins.str,os.PathLike[builtins.str]]
 builtins.str"builtins.strF
 os.PathLike[builtins.str]
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
 )pandas._typing.ReadBuffer[builtins.bytes] 
-builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer 
-builtins.bytes"builtins.bytesB
+builtins.bytes"builtins.bytes"pandas._typing.ReadBufferB
 pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile
 Any
 Any
@@ -2657,33 +3096,31 @@ sheet_name`
 pandas._typing.HashableT"
 typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
 builtins.range"builtins.range"pandas._typing.ListLikeHashable
-None *
-	index_col
-6Union[builtins.int,typing.Sequence[builtins.int],None]
+None *
+	index_col
+CUnion[builtins.int,typing.Sequence[builtins.int],builtins.str,None]
 builtins.int"builtins.intN
 typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
-None *
-
-usecols
-
-Union[builtins.str,TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]]
-builtins.str"builtins.str
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+builtins.int"builtins.int"typing.Sequence
+builtins.str"builtins.str
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -2710,9 +3147,11 @@ $typing.MutableSequence[builtins.str]
 builtins.str"builtins.str?
 Union[builtins.str,Unknown]
 builtins.str"builtins.str"typing.Mapping
-None *
-engine
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+None *
+engine
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -2720,7 +3159,9 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ExcelReadEngine
 None *
 
 converters
@@ -2825,8 +3266,8 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX"
-	read_jsonpandas.io.json._json.read_json9
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX"
+	read_jsonpandas.io.json._json.read_json;
 	read_jsonpandas.io.json._json.read_json"
 ?pandas.io.json._json.JsonReader[pandas.core.series.Series[Any]]D
 pandas.core.series.Series[Any]
@@ -2897,9 +3338,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 keep_default_dates
 
builtins.bool"
builtins.bool *3
 
precise_float
-
builtins.bool"
builtins.bool *
-	date_unit
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+
builtins.bool"
builtins.bool *
+	date_unit
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -2907,7 +3350,7 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
+builtins.str"builtins.str"pandas._typing.TimeUnit
 None *T
 encodingD
 Union[builtins.str,None]
@@ -2972,7 +3415,7 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX;
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX=
 	read_jsonpandas.io.json._json.read_json"
 Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
 typing.Hashable"typing.Hashable
 'builtins.list[pandas._typing.HashableT]Q
 pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
-None *|
-subplotsl
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list *|
+subplotsl
 "Union[Literal[builtins.bool],None]:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
 None *
 kwargs
-Any0:typing.overloadX
+Any0:typing.overloadX
 box&pandas.plotting._core.PlotAccessor.box"D
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series*R
 selfH
-"pandas.plotting._core.PlotAccessor""pandas.plotting._core.PlotAccessor*
-by
-CUnion[typing.Hashable,builtins.list[pandas._typing.HashableT],None]"
+"pandas.plotting._core.PlotAccessor""pandas.plotting._core.PlotAccessor*
+by
+>Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
 typing.Hashable"typing.Hashable
 'builtins.list[pandas._typing.HashableT]Q
 pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
-None *J
-subplots:
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list *H
+subplots:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool*
 kwargs
 Any0:typing.overloadX2
 hist'pandas.plotting._core.PlotAccessor.hist
diff --git a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.protobuf b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.protobuf
index f6a4e875da..1ef3b7495f 100644
--- a/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.protobuf
+++ b/python-frontend/src/main/resources/org/sonar/python/types/third_party_protobuf_mypy/pandas.protobuf
@@ -13,16 +13,18 @@ ArrowDtype)pandas.core.arrays.arrow.dtype.ArrowDtype"-pandas.core.dtypes.base.S
 selfV
 )pandas.core.arrays.arrow.dtype.ArrowDtype")pandas.core.arrays.arrow.dtype.ArrowDtype0:builtins.property`rQ
 
pyarrow_dtype7pandas.core.arrays.arrow.dtype.ArrowDtype.pyarrow_dtype
-Any
-BooleanDtype'pandas.core.arrays.boolean.BooleanDtype"&pandas.core.dtypes.base.ExtensionDtype*
+Any
+BooleanDtype'pandas.core.arrays.boolean.BooleanDtype"&pandas.core.dtypes.base.ExtensionDtype*
+na_value0pandas.core.arrays.boolean.BooleanDtype.na_value":
+pandas._libs.missing.NAType"pandas._libs.missing.NAType*\
+selfR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype0:builtins.property`*
 construct_array_type
+__new__5pandas.core.indexes.category.CategoricalIndex.__new__"
+2pandas.core.indexes.category.CategoricalIndex.Self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -667,20 +499,17 @@ $TypeAlias[Union[builtins.bool,None]]G
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex(*
-cls
-8Type[pandas.core.indexes.category.CategoricalIndex.Self]
-2pandas.core.indexes.category.CategoricalIndex.Self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex(*
+cls
+8Type[pandas.core.indexes.category.CategoricalIndex.Self]
+2pandas.core.indexes.category.CategoricalIndex.Self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -707,18 +536,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex("type*
-data
-"typing.Iterable[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex"-pandas.core.indexes.category.CategoricalIndex("type*
+data
+"typing.Iterable[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -745,14 +571,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Iterable *
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterable *
 
 categories
 Any *
@@ -766,13 +589,13 @@ categories
 Any *S
 equals4pandas.core.indexes.category.CategoricalIndex.equals*
 self*	
-other*
+other*
 
inferred_type;pandas.core.indexes.category.CategoricalIndex.inferred_type"
-builtins.str"builtins.str*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -799,21 +622,18 @@ categories
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*_
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*_
 values4pandas.core.indexes.category.CategoricalIndex.values*
-self0:builtins.property`*
+self0:builtins.property`*
 __contains__:pandas.core.indexes.category.CategoricalIndex.__contains__"
-
builtins.bool"
builtins.bool*
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -840,23 +660,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*	
-Any*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*	
+Any*
 	__array__7pandas.core.indexes.category.CategoricalIndex.__array__"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -883,23 +700,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 dtype
-Any *&
+Any *#
 astype4pandas.core.indexes.category.CategoricalIndex.astype"N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.indexes.base.Index*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -926,14 +740,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 dtype
 TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
 Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
@@ -960,13 +771,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fillna4pandas.core.indexes.category.CategoricalIndex.fillna*
 self*
 value *
-downcast *
+downcast *
 	is_unique7pandas.core.indexes.category.CategoricalIndex.is_unique"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -993,20 +804,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
 is_monotonic_increasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_increasing"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1033,20 +841,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*
 is_monotonic_decreasingEpandas.core.indexes.category.CategoricalIndex.is_monotonic_decreasing"
-
builtins.bool"
builtins.bool*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1073,24 +878,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*U
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex0:builtins.property`*U
 unique4pandas.core.indexes.category.CategoricalIndex.unique*
 self*
-level *
+level *
 
 duplicated8pandas.core.indexes.category.CategoricalIndex.duplicated"
-Any*
-self
-@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+self
+@pandas.core.indexes.category.CategoricalIndex[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -1117,14 +919,11 @@ duplicated8pandas.core.indexes.category.CategoricalIndex.duplicated"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"-pandas.core.indexes.category.CategoricalIndex*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"-pandas.core.indexes.category.CategoricalIndex*
 keep
 IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
@@ -1132,14 +931,7 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 Literal[builtins.str]	
 builtins.str"builtins.str:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *S
-get_loc5pandas.core.indexes.category.CategoricalIndex.get_loc*
-self*
-key*l
-	get_value7pandas.core.indexes.category.CategoricalIndex.get_value*
-self*
-seriesArrayLike*
-key*]
+
builtins.bool"
builtins.bool *]
 where3pandas.core.indexes.category.CategoricalIndex.where*
 self*
 cond*
@@ -1162,16 +954,7 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 get_indexer_non_uniqueDpandas.core.indexes.category.CategoricalIndex.get_indexer_non_unique*
 self*
 
-target*`
-take_nd5pandas.core.indexes.category.CategoricalIndex.take_nd*
-self*
-args*
-
-kwargs*N
-map1pandas.core.indexes.category.CategoricalIndex.map*
-self*
-
-mapper*Q
+target*Q
 delete4pandas.core.indexes.category.CategoricalIndex.delete*
 self*
 loc*[
@@ -1186,7 +969,7 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 
 categories8pandas.core.indexes.category.CategoricalIndex.categoriesN
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index
+Any"pandas.core.indexes.base.IndexD
 	DataFramepandas.core.frame.DataFrame"pandas.core.generic.NDFrame"pandas.core.arraylike.OpsMixin*
 
__dataframe__)pandas.core.frame.DataFrame.__dataframe__"l
 4pandas.core.interchange.dataframe_protocol.DataFrame"4pandas.core.interchange.dataframe_protocol.DataFrame*D
@@ -1196,7 +979,15 @@ categories8pandas.core.indexes.category.CategoricalIndex.categoriesN
 
builtins.bool"
builtins.bool *0
 
 allow_copy
-
builtins.bool"
builtins.bool *
+
builtins.bool"
builtins.bool *
+__arrow_c_stream__.pandas.core.frame.DataFrame.__arrow_c_stream__""
+builtins.object"builtins.object*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*e
+requested_schemaM
+Union[builtins.object,None]"
+builtins.object"builtins.object
+None *
 axes pandas.core.frame.DataFrame.axes"
 2builtins.list[pandas.core.indexes.base.Index[Any]]N
 #pandas.core.indexes.base.Index[Any]
@@ -1220,57 +1011,21 @@ Ftyping.Iterable[Tuple[typing.Hashable,pandas.core.series.Series[Any]]]
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series"typing.Iterable*D
 self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-iterrows$pandas.core.frame.DataFrame.iterrows"
-]typing.Iterable[Tuple[TypeAlias[Union[typing.Hashable,None]],pandas.core.series.Series[Any]]]
-LTuple[TypeAlias[Union[typing.Hashable,None]],pandas.core.series.Series[Any]]
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.LabelD
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+iterrows$pandas.core.frame.DataFrame.iterrows"
+Ftyping.Iterable[Tuple[typing.Hashable,pandas.core.series.Series[Any]]]
+5Tuple[typing.Hashable,pandas.core.series.Series[Any]]"
+typing.Hashable"typing.HashableD
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series"typing.Iterable*D
 self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-
-itertuples&pandas.core.frame.DataFrame.itertuples"
-Any*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*+
-index
-
builtins.bool"
builtins.bool *P
-nameD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 __len__#pandas.core.frame.DataFrame.__len__"
 builtins.int"builtins.int*<:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*8
 
 __matmul__&pandas.core.frame.DataFrame.__matmul__***:
-__rmatmul__'pandas.core.frame.DataFrame.__rmatmul__***
-	from_dict%pandas.core.frame.DataFrame.from_dict":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*p
-clsg
-!Type[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"type*C
-data9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict*
-orient
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *)
-dtype
-builtins.str"builtins.str *Y
-columnsJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list 0:builtins.classmethodp*
+__rmatmul__'pandas.core.frame.DataFrame.__rmatmul__***
 to_numpy$pandas.core.frame.DataFrame.to_numpy"9
 numpy.ndarray[Any,Any]
 Any
@@ -1592,21 +1347,32 @@ jUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 *pandas._typing.WriteBuffer[builtins.bytes] 
 builtins.bytes"builtins.bytes"pandas._typing.WriteBuffer*
 kwargs
-Any*
+Any*
 info pandas.core.frame.DataFrame.info"
 None*D
 self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-verbose
-Any *
-buf
-Any *
-max_cols
-Any *
-memory_usage
-Any *
-null_counts
-Any *
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*V
+verboseG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *o
+bufd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer *T
+max_colsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+memory_usage
+/Union[builtins.bool,Literal[builtins.str],None]
+
builtins.bool"
builtins.bool7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *Z
+show_countsG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
 memory_usage(pandas.core.frame.DataFrame.memory_usage"D
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series*D
@@ -1684,23 +1450,7 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 inplace
 
builtins.bool"
builtins.bool *
 kwargs
-Any*
-
select_dtypes)pandas.core.frame.DataFrame.select_dtypes":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-include
-4Union[builtins.str,builtins.list[builtins.str],None]
-builtins.str"builtins.strJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-exclude
-4Union[builtins.str,builtins.list[builtins.str],None]
-builtins.str"builtins.strJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
+Any*
 insert"pandas.core.frame.DataFrame.insert"
 None*D
 self:
@@ -1748,21 +1498,7 @@ uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any
 self:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 kwargs
-Any*
-lookup"pandas.core.frame.DataFrame.lookup"9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*@
-
-row_labels0
-typing.Sequence[Any]
-Any"typing.Sequence*@
-
-col_labels0
-typing.Sequence[Any]
-Any"typing.Sequence*&
+Any*&
 align!pandas.core.frame.DataFrame.align"
 :Tuple[pandas.core.frame.DataFrame,pandas._typing.NDFrameT]:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFramet
@@ -2049,13 +1785,17 @@ fill_valueM
 notnull#pandas.core.frame.DataFrame.notnull":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
 self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 drop_duplicates+pandas.core.frame.DataFrame.drop_duplicates":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
 self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-subset
-Any *
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+subset
+Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
-typing.Hashable"typing.Hashable
-'builtins.list[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX
-reset_index'pandas.core.frame.DataFrame.reset_index":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-level
-NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level-
-typing.Sequence[Unknown]"typing.Sequence *q
-	col_level`
- Union[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str *2
-col_fill"
-typing.Hashable"typing.Hashable **
-drop
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *6
-allow_duplicates
-
builtins.bool"
builtins.bool *
-names
->Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
-typing.Hashable"typing.Hashable
-'builtins.list[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX	
-reset_index'pandas.core.frame.DataFrame.reset_index"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-level
-NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level-
-typing.Sequence[Unknown]"typing.Sequence **
-drop
-
builtins.bool"
builtins.bool *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *q
-	col_level`
- Union[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str *2
-col_fill"
-typing.Hashable"typing.Hashable *6
-allow_duplicates
-
builtins.bool"
builtins.bool *
-names
->Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
-typing.Hashable"typing.Hashable
-'builtins.list[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX2`
-dropna"pandas.core.frame.DataFrame.dropna
-dropna"pandas.core.frame.DataFrame.dropna"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-how
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *R
-threshD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-subset
-Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
-TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
-uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX 
-dropna"pandas.core.frame.DataFrame.dropna":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-how
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *R
-threshD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-subset
-Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
-TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
-uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadX 
-dropna"pandas.core.frame.DataFrame.dropna"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-how
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *R
-threshD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-subset
-Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
-TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
-uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-None *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None 0:typing.overloadX2:
-sort_values'pandas.core.frame.DataFrame.sort_values
-sort_values'pandas.core.frame.DataFrame.sort_values"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-1Union[builtins.str,typing.Sequence[builtins.str]]
-builtins.str"builtins.strN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8527,56 +6478,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX
-sort_values'pandas.core.frame.DataFrame.sort_values":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-1Union[builtins.str,typing.Sequence[builtins.str]]
-builtins.str"builtins.strN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8584,62 +6494,19 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX
-sort_values'pandas.core.frame.DataFrame.sort_values"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-1Union[builtins.str,typing.Sequence[builtins.str]]
-builtins.str"builtins.strN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8647,58 +6514,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2A
-
-sort_index&pandas.core.frame.DataFrame.sort_index
-
-sort_index&pandas.core.frame.DataFrame.sort_index"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8706,65 +6530,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX
-
-sort_index&pandas.core.frame.DataFrame.sort_index":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8772,71 +6546,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX
-
-sort_index&pandas.core.frame.DataFrame.sort_index"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -8844,1227 +6562,317 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2
-groupby#pandas.core.frame.DataFrame.groupby)
-groupby#pandas.core.frame.DataFrame.groupby"
-pandas.core.groupby.generic.DataFrameGroupBy[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"
-Vpandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*b
-byZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"
-Vpandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*f
-by^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"
-Opandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.period.Period]F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*X
-byP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
 
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"
-Fpandas.core.groupby.generic.DataFrameGroupBy[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+numpy.void"
+numpy.void"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg
+None *
 
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX&
-groupby#pandas.core.frame.DataFrame.groupby"
-Apandas.core.groupby.generic.DataFrameGroupBy[builtins.tuple[Any]].
-builtins.tuple[Any]
-Any"builtins.tuple",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-Union[pandas.core.indexes.multi.MultiIndex,TypeAlias[Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]]],None]L
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex
-TypeAlias[Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]]]
-Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]].
-builtins.tuple[Any]
-Any"builtins.tuple
-)builtins.list[pandas._typing._HashableTa]S
-pandas._typing._HashableTa"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
-=TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]]
-2Union[numpy.ufunc,CallableType[builtins.function]]
-numpy.ufunc"numpy.ufuncK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Function)
-builtins.list[Unknown]"
builtins.list
--builtins.list[pandas.core.series.Series[Any]]D
+columns
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"
builtins.list9
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayq
-%builtins.list[numpy.ndarray[Any,Any]]9
-numpy.ndarray[Any,Any]
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.list
-:typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any]
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label
-Any"typing.Mappingu
-*builtins.list[typing.Mapping[Unknown,Any]]8
-typing.Mapping[Unknown,Any]
-Any"typing.Mapping"
builtins.list
-2builtins.list[pandas.core.indexes.base.Index[Any]]N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"
builtins.listJ
-#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper
-2builtins.list[pandas.core.groupby.grouper.Grouper]J
-#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"
builtins.list"%pandas._typing.GroupByObjectNonScalar
-None *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None 0:typing.overload:builtins.classmethodXp
+	from_dict%pandas.core.frame.DataFrame.from_dict":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*p
+clsg
+!Type[pandas.core.frame.DataFrame]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"type*C
+data9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict*
+orient
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+dtype
+4Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],None]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX!
-groupby#pandas.core.frame.DataFrame.groupby"
-Fpandas.core.groupby.generic.DataFrameGroupBy[pandas._typing.SeriesByT]
-
-pandas._typing.SeriesByT	
-Union[builtins.str,builtins.bytes,datetime.date,builtins.bool,builtins.int,builtins.float,builtins.complex,datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-
-by
-
-3pandas.core.series.Series[pandas._typing.SeriesByT]
-
-pandas._typing.SeriesByT	
-Union[builtins.str,builtins.bytes,datetime.date,builtins.bool,builtins.int,builtins.float,builtins.complex,datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX
-groupby#pandas.core.frame.DataFrame.groupby"j
-1pandas.core.groupby.generic.DataFrameGroupBy[Any]
-Any",pandas.core.groupby.generic.DataFrameGroupBy*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-by
-|Union[pandas.core.indexes.category.CategoricalIndex[Any],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any]]l
-2pandas.core.indexes.category.CategoricalIndex[Any]
-Any"-pandas.core.indexes.category.CategoricalIndexN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-as_index
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *0
-
-group_keys
-
builtins.bool"
builtins.bool *-
-squeeze
-
builtins.bool"
builtins.bool *.
-observed
-
builtins.bool"
builtins.bool *,
-dropna
-
builtins.bool"
builtins.bool 0:typing.overloadX2
-aggpandas.core.frame.DataFrame.agg
-
-aggpandas.core.frame.DataFrame.agg"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-kwargs
-Any0:typing.overloadX
-aggpandas.core.frame.DataFrame.agg":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-func
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-kwargs
-Any0:typing.overloadX2
-	aggregate%pandas.core.frame.DataFrame.aggregate
-	aggregate%pandas.core.frame.DataFrame.aggregate"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-kwargs
-Any0:typing.overloadX
-	aggregate%pandas.core.frame.DataFrame.aggregate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-func
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-kwargs
-Any0:typing.overloadX2
-apply!pandas.core.frame.DataFrame.apply
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-kwargs
-Any0:typing.overloadX!
-apply!pandas.core.frame.DataFrame.apply"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *
-result_type
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-
-apply!pandas.core.frame.DataFrame.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-result_type
-None *
-args
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn*
-kwargs
-Any0:typing.overloadX
-apply!pandas.core.frame.DataFrame.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
-fK
-CallableType[builtins.function]&
-builtins.function"builtins.function*)
-raw
-
builtins.bool"
builtins.bool *
-args
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn*H
-result_type7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-kwargs
-Any0:typing.overloadX2
-count!pandas.core.frame.DataFrame.count
-
-count!pandas.core.frame.DataFrame.count":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
-numeric_only
-
builtins.bool"
builtins.bool *
-level
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level0:typing.overloadX
-count!pandas.core.frame.DataFrame.count"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool 0:typing.overloadX2
-mode pandas.core.frame.DataFrame.mode
-
-mode pandas.core.frame.DataFrame.mode":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *,
-skipna
-
builtins.bool"
builtins.bool *2
-numeric_only
-
builtins.bool"
builtins.bool *
-level
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level*
-kwargs
-Any0:typing.overloadX	
-mode pandas.core.frame.DataFrame.mode"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX2!
-quantile$pandas.core.frame.DataFrame.quantile
-quantile$pandas.core.frame.DataFrame.quantile"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*)
-q 
-builtins.float"builtins.float *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
-numeric_only
-
builtins.bool"
builtins.bool *
-
interpolation
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod 0:typing.overloadX
-quantile$pandas.core.frame.DataFrame.quantile":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-q
-;Union[builtins.list[builtins.float],numpy.ndarray[Any,Any]]P
-builtins.list[builtins.float] 
-builtins.float"builtins.float"
builtins.list9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
-numeric_only
-
builtins.bool"
builtins.bool *
-
interpolation
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10072,289 +6880,75 @@ tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod 0:typing.overloadX2
-
-columns#pandas.core.frame.DataFrame.columns
-columns#pandas.core.frame.DataFrame.columns"l
-,pandas.core.indexes.base.Index[builtins.str]
-builtins.str"builtins.str"pandas.core.indexes.base.Index*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame0:builtins.propertyX`
-columns#pandas.core.frame.DataFrame.columns"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-cols
-Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[pandas._typing.HashableT],builtins.tuple[pandas._typing.HashableT]]
-kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
-`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.AnyArrayLike
-'builtins.list[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
-(builtins.tuple[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple0:.setter2
-index!pandas.core.frame.DataFrame.index
-index!pandas.core.frame.DataFrame.index"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame0:builtins.propertyX`
-index!pandas.core.frame.DataFrame.index"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*W
-idxN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index0:.setter2
-allpandas.core.frame.DataFrame.all
-allpandas.core.frame.DataFrame.all"
-
builtins.bool"
builtins.bool*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-None*X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX	
-allpandas.core.frame.DataFrame.all"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX2
-anypandas.core.frame.DataFrame.any
-anypandas.core.frame.DataFrame.any"
-
builtins.bool"
builtins.bool*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-None*X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX	
-anypandas.core.frame.DataFrame.any"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX2
-bfill!pandas.core.frame.DataFrame.bfill
-bfill!pandas.core.frame.DataFrame.bfill"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX
-bfill!pandas.core.frame.DataFrame.bfill":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2
-ffill!pandas.core.frame.DataFrame.ffill
-ffill!pandas.core.frame.DataFrame.ffill"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX
-ffill!pandas.core.frame.DataFrame.ffill":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2X
-interpolate'pandas.core.frame.DataFrame.interpolate
-interpolate'pandas.core.frame.DataFrame.interpolate"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-method
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10372,6 +6966,16 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -10380,6 +6984,10 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -10390,59 +6998,29 @@ kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[A
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-limit_direction
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-
-limit_area
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *x
-downcasth
-!Union[Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-kwargs
-Any0:typing.overloadX
-interpolate'pandas.core.frame.DataFrame.interpolate":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-method
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10478,61 +7056,23 @@ limit_area
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-limit_direction
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-
-limit_area
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *x
-downcasth
-!Union[Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX
-interpolate'pandas.core.frame.DataFrame.interpolate"q
-'Union[pandas.core.frame.DataFrame,None]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-method
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10566,226 +7106,41 @@ limit_area
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-limit_direction
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-
-limit_area
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *x
-downcasth
-!Union[Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *
-kwargs
-Any0:typing.overloadX2,
-rename_axis'pandas.core.frame.DataFrame.rename_axis
-
-rename_axis'pandas.core.frame.DataFrame.rename_axis"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-mapper
-Any *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX
-
-rename_axis'pandas.core.frame.DataFrame.rename_axis":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-mapper
-Any *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadX
-rename_axis'pandas.core.frame.DataFrame.rename_axis"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-index
-Union[builtins.str,typing.Sequence[builtins.str],builtins.dict[Union[builtins.str,builtins.int],builtins.str],CallableType[builtins.function],None]
-builtins.str"builtins.strN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence
-pandas.core.window.rolling.Window[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"!pandas.core.window.rolling.Window*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-window
-{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
-builtins.int"builtins.int
-builtins.str"builtins.str(
-datetime.timedelta"datetime.timedeltaP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
- pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
-min_periodsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *,
-center
-
builtins.bool"
builtins.bool *W
-onM
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-closed
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10793,62 +7148,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType
-None *P
-stepD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod **
-win_type
-builtins.str"builtins.str0:typing.overloadX
-rolling#pandas.core.frame.DataFrame.rolling"
-?pandas.core.window.rolling.Rolling[pandas.core.frame.DataFrame]:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame""pandas.core.window.rolling.Rolling*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-window
-{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
-builtins.int"builtins.int
-builtins.str"builtins.str(
-datetime.timedelta"datetime.timedeltaP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
- pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
-min_periodsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *,
-center
-
builtins.bool"
builtins.bool *W
-onM
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-closed
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10856,71 +7164,19 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType
-None *P
-stepD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod *
-win_type
-None 0:typing.overloadX2[
-to_json#pandas.core.frame.DataFrame.to_json
-to_json#pandas.core.frame.DataFrame.to_json"
-None*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-path_or_buf
-hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
-8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
--Union[builtins.str,os.PathLike[builtins.str]]
-builtins.str"builtins.strF
-os.PathLike[builtins.str]
-builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
-(pandas._typing.WriteBuffer[builtins.str]
-builtins.str"builtins.str"pandas._typing.WriteBuffer*C
-orient7
-Literal[builtins.str]	
-builtins.str"builtins.str*
-date_format
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *4
-double_precision
-builtins.int"builtins.int *1
-force_ascii
-
builtins.bool"
builtins.bool *
-	date_unit
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-default_handler
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None *E
-lines:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-compression
-TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
-Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
-None7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10932,42 +7188,15 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-*TypeAlias[builtins.dict[builtins.str,Any]]W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
-index
-
builtins.bool"
builtins.bool *R
-indentD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *A
-mode7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str0:typing.overloadX
-to_json#pandas.core.frame.DataFrame.to_json"
-builtins.str"builtins.str*D
-self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-path_or_buf
-None *C
-orient7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str*
-date_format
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *4
-double_precision
-builtins.int"builtins.int *1
-force_ascii
-
builtins.bool"
builtins.bool *
-	date_unit
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -10975,58 +7204,89 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-default_handler
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None *E
-lines:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-compression
-TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
-Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
-None7
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-*TypeAlias[builtins.dict[builtins.str,Any]]W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
-index
-
builtins.bool"
builtins.bool *R
-indentD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *A
-mode7
-Literal[builtins.str]	
-builtins.str"builtins.str0:typing.overloadX
-to_json#pandas.core.frame.DataFrame.to_json"
-builtins.str"builtins.str*D
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg
+None 0:typing.overload:builtins.classmethodXp20
+to_dict#pandas.core.frame.DataFrame.to_dict
+to_dict#pandas.core.frame.DataFrame.to_dict"
+9builtins.list[typing.MutableMapping[typing.Hashable,Any]]p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping"
builtins.list*D
 self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-path_or_buf
-None *
-orient
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
+orient7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str*
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"
+1builtins.list[builtins.dict[typing.Hashable,Any]]`
+"builtins.dict[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"
builtins.dict"
builtins.list*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
+orient7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str*m
+intoa
+Type[builtins.dict[Any,Any]]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict"type *G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -11034,20 +7294,49 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.JsonFrameOrient
-None *
-date_format
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str*
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-None *4
-double_precision
-builtins.int"builtins.int *1
-force_ascii
-
builtins.bool"
builtins.bool *
-	date_unit
+builtins.str"builtins.str*
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*+
+index
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
 ^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
@@ -11056,22 +7345,50 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-default_handler
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None *+
-lines
-
builtins.bool"
builtins.bool *
-compression
-TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
-Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
-None7
+builtins.str"builtins.str *
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"p
+*typing.MutableMapping[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"typing.MutableMapping*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str *
+into
+JUnion[typing.MutableMapping[Any,Any],Type[typing.MutableMapping[Any,Any]]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMappingy
+$Type[typing.MutableMapping[Any,Any]]I
+typing.MutableMapping[Any,Any]
+Any
+Any"typing.MutableMapping"type*+
+index
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"`
+"builtins.dict[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"
builtins.dict*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -11079,82 +7396,109 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
-*TypeAlias[builtins.dict[builtins.str,Any]]W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
-index
-
builtins.bool"
builtins.bool *R
-indentD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *C
-mode7
+builtins.str"builtins.str *m
+intoa
+Type[builtins.dict[Any,Any]]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict"type *G
+index:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+to_dict#pandas.core.frame.DataFrame.to_dict"`
+"builtins.dict[typing.Hashable,Any]"
+typing.Hashable"typing.Hashable
+Any"
builtins.dict*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+orient
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
-builtins.str"builtins.str 0:typing.overloadX
-to_json#pandas.core.frame.DataFrame.to_json"
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *m
+intoa
+Type[builtins.dict[Any,Any]]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict"type *+
+index
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+
+to_parquet&pandas.core.frame.DataFrame.to_parquet
+
+to_parquet&pandas.core.frame.DataFrame.to_parquet"
 None*D
 self:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-path_or_buf
-hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path
+jUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.bytes]]
 8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
 -Union[builtins.str,os.PathLike[builtins.str]]
 builtins.str"builtins.strF
 os.PathLike[builtins.str]
-builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
-(pandas._typing.WriteBuffer[builtins.str]
-builtins.str"builtins.str"pandas._typing.WriteBuffer*
-orient
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathj
+*pandas._typing.WriteBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.WriteBuffer*
+engine
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.ParquetEngine *
+compression
+yUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.JsonFrameOrient
-None *
-date_format
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str
-None *4
-double_precision
-builtins.int"builtins.int *1
-force_ascii
-
builtins.bool"
builtins.bool *
-	date_unit
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *T
+indexG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+partition_cols
+3Union[builtins.list[pandas._typing.HashableT],None]
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions *
+kwargs
+Any0:typing.overloadX
+
+to_parquet&pandas.core.frame.DataFrame.to_parquet" 
+builtins.bytes"builtins.bytes*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path
+None *
+engine
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-default_handler
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None *+
-lines
-
builtins.bool"
builtins.bool *
-compression
-TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
-Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
-None7
+builtins.str"builtins.str"pandas._typing.ParquetEngine *
+compression
+yUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -11164,24 +7508,75 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str
+None *T
+indexG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+partition_cols
+3Union[builtins.list[pandas._typing.HashableT],None]
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions *
+kwargs
+Any0:typing.overloadX2
+to_orc"pandas.core.frame.DataFrame.to_orc
+to_orc"pandas.core.frame.DataFrame.to_orc"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path
+jUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.bytes]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathj
+*pandas._typing.WriteBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.WriteBuffer*E
+engine7
 Literal[builtins.str]	
-builtins.str"builtins.str
-*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.str"builtins.str *T
+indexG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+
engine_kwargs
++Union[builtins.dict[builtins.str,Any],None]W
 builtins.dict[builtins.str,Any]
 builtins.str"builtins.str
-Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
-index
-
builtins.bool"
builtins.bool *R
-indentD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *C
-mode7
+Any"
builtins.dict
+None 0:typing.overloadX
+to_orc"pandas.core.frame.DataFrame.to_orc" 
+builtins.bytes"builtins.bytes*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path
+None *E
+engine7
 Literal[builtins.str]	
-builtins.str"builtins.str 0:typing.overloadX2;
-	to_string%pandas.core.frame.DataFrame.to_string 
-	to_string%pandas.core.frame.DataFrame.to_string"
+builtins.str"builtins.str *T
+indexG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+
engine_kwargs
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None 0:typing.overloadX2I
+to_html#pandas.core.frame.DataFrame.to_html&
+to_html#pandas.core.frame.DataFrame.to_html"
 None*D
 self:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
@@ -11193,55 +7588,52 @@ hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.W
 os.PathLike[builtins.str]
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
 (pandas._typing.WriteBuffer[builtins.str]
-builtins.str"builtins.str"pandas._typing.WriteBuffer*
-columns
-wUnion[builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
+builtins.str"builtins.str"pandas._typing.WriteBuffer*
+columns
+vUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
 typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.IndexD
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series
-None *
-	col_space
-jUnion[builtins.int,builtins.list[builtins.int],builtins.dict[pandas._typing.HashableT2,builtins.int],None]
-builtins.int"builtins.intJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-5builtins.dict[pandas._typing.HashableT2,builtins.int]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable
-builtins.int"builtins.int"
builtins.dict
-None *
-header
-MUnion[builtins.bool,builtins.list[builtins.str],builtins.tuple[builtins.str]]
-
builtins.bool"
builtins.boolJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.listL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tuple *+
+None *
+	col_space
+Union[TypeAlias[Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]],None]
+TypeAlias[Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]]
+Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]
+builtins.str"builtins.str
+builtins.int"builtins.int
+1typing.Sequence[Union[builtins.int,builtins.str]]`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str"typing.Sequence
+@typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]"
+typing.Hashable"typing.Hashable`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.int"typing.Mapping"pandas._typing.ColspaceArgType
+None *,
+header
+
builtins.bool"
builtins.bool *+
 index
 
builtins.bool"
builtins.bool **
 na_rep
-builtins.str"builtins.str *	
+builtins.str"builtins.str *
 
-formatters	
-Union[TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]],None]
-TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]]
-Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]
+formatters
+Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[typing.Hashable,CallableType[builtins.function]],None]
 .builtins.list[CallableType[builtins.function]]K
 CallableType[builtins.function]&
 builtins.function"builtins.function"
builtins.list
 /builtins.tuple[CallableType[builtins.function]]K
 CallableType[builtins.function]&
-builtins.function"builtins.function"builtins.tuple
-Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]`
- Union[builtins.str,builtins.int]
-builtins.str"builtins.str
-builtins.int"builtins.intK
+builtins.function"builtins.function"builtins.tuple
+?typing.Mapping[typing.Hashable,CallableType[builtins.function]]"
+typing.Hashable"typing.HashableK
 CallableType[builtins.function]&
-builtins.function"builtins.function"typing.Mapping"pandas._typing.FormattersType
+builtins.function"builtins.function"typing.Mapping
 None *
 float_format
 +Union[CallableType[builtins.function],None]K
@@ -11253,9 +7645,30 @@ Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]
 
builtins.bool"
builtins.bool
 None *1
 index_names
-
builtins.bool"
builtins.bool *S
-justifyD
-Union[builtins.str,None]
+
builtins.bool"
builtins.bool *
+justify
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
 builtins.str"builtins.str
 None *T
 max_rowsD
@@ -11269,75 +7682,79 @@ Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]
 show_dimensions
 
builtins.bool"
builtins.bool *+
 decimal
-builtins.str"builtins.str *V
-
-line_widthD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *T
-min_rowsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *X
-max_colwidthD
+builtins.str"builtins.str */
+	bold_rows
+
builtins.bool"
builtins.bool *
+classes
+)Union[typing.Sequence[builtins.str],None]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+None *,
+escape
+
builtins.bool"
builtins.bool *.
+notebook
+
builtins.bool"
builtins.bool *R
+borderD
 Union[builtins.int,None]
 builtins.int"builtins.int
 None *T
+table_idD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *2
+render_links
+
builtins.bool"
builtins.bool *T
 encodingD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None 0:typing.overloadX
-	to_string%pandas.core.frame.DataFrame.to_string"
+None 0:typing.overloadX!
+to_html#pandas.core.frame.DataFrame.to_html"
 builtins.str"builtins.str*D
 self:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 buf
-None *
-columns
-vUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
-'builtins.list[pandas._typing.HashableT]Q
+None *
+columns
+5Union[typing.Sequence[pandas._typing.HashableT],None]
+)typing.Sequence[pandas._typing.HashableT]Q
 pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None *
-	col_space
-`Union[builtins.int,builtins.list[builtins.int],builtins.dict[typing.Hashable,builtins.int],None]
-builtins.int"builtins.intJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list~
-+builtins.dict[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"
builtins.dict
-None *
-header
-2Union[builtins.bool,typing.Sequence[builtins.str]]
-
builtins.bool"
builtins.boolN
-typing.Sequence[builtins.str]
-builtins.str"builtins.str"typing.Sequence *+
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Sequence
+None *
+	col_space
+Union[TypeAlias[Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]],None]
+TypeAlias[Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]]
+Union[builtins.str,builtins.int,typing.Sequence[Union[builtins.int,builtins.str]],typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]]
+builtins.str"builtins.str
+builtins.int"builtins.int
+1typing.Sequence[Union[builtins.int,builtins.str]]`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str"typing.Sequence
+@typing.Mapping[typing.Hashable,Union[builtins.str,builtins.int]]"
+typing.Hashable"typing.Hashable`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.int"typing.Mapping"pandas._typing.ColspaceArgType
+None *,
+header
+
builtins.bool"
builtins.bool *+
 index
 
builtins.bool"
builtins.bool **
 na_rep
-builtins.str"builtins.str *	
+builtins.str"builtins.str *
 
-formatters	
-Union[TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]],None]
-TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]]
-Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]
+formatters
+Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[typing.Hashable,CallableType[builtins.function]],None]
 .builtins.list[CallableType[builtins.function]]K
 CallableType[builtins.function]&
 builtins.function"builtins.function"
builtins.list
 /builtins.tuple[CallableType[builtins.function]]K
 CallableType[builtins.function]&
-builtins.function"builtins.function"builtins.tuple
-Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]`
- Union[builtins.str,builtins.int]
-builtins.str"builtins.str
-builtins.int"builtins.intK
+builtins.function"builtins.function"builtins.tuple
+?typing.Mapping[typing.Hashable,CallableType[builtins.function]]"
+typing.Hashable"typing.HashableK
 CallableType[builtins.function]&
-builtins.function"builtins.function"typing.Mapping"pandas._typing.FormattersType
+builtins.function"builtins.function"typing.Mapping
 None *
 float_format
 +Union[CallableType[builtins.function],None]K
@@ -11349,9 +7766,30 @@ Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]
 
builtins.bool"
builtins.bool
 None *1
 index_names
-
builtins.bool"
builtins.bool *S
-justifyD
-Union[builtins.str,None]
+
builtins.bool"
builtins.bool *
+justify
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
 builtins.str"builtins.str
 None *T
 max_rowsD
@@ -11365,1100 +7803,9592 @@ Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]
 show_dimensions
 
builtins.bool"
builtins.bool *+
 decimal
-builtins.str"builtins.str *V
-
-line_widthD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *T
-min_rowsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *X
-max_colwidthD
+builtins.str"builtins.str */
+	bold_rows
+
builtins.bool"
builtins.bool *
+classes
+)Union[typing.Sequence[builtins.str],None]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+None *,
+escape
+
builtins.bool"
builtins.bool *.
+notebook
+
builtins.bool"
builtins.bool *R
+borderD
 Union[builtins.int,None]
 builtins.int"builtins.int
 None *T
+table_idD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *2
+render_links
+
builtins.bool"
builtins.bool *T
 encodingD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None 0:typing.overloadXr:
-__hash__$pandas.core.frame.DataFrame.__hash__
-NonerT
-sparse"pandas.core.frame.DataFrame.sparse&
-builtins.ellipsis"builtins.ellipsisrF
-Name pandas.core.frame.DataFrame.Name
-builtins.str"builtins.str	
-
-DateOffset&pandas._libs.tslibs.offsets.DateOffset"/pandas._libs.tslibs.offsets.RelativeDeltaOffset*
-__init__/pandas._libs.tslibs.offsets.DateOffset.__init__"
-None*Z
-selfP
-&pandas._libs.tslibs.offsets.DateOffset"&pandas._libs.tslibs.offsets.DateOffset*%
-n
-builtins.int"builtins.int */
-	normalize
-
builtins.bool"
builtins.bool *)
-years
-builtins.int"builtins.int **
-months
-builtins.int"builtins.int *)
-weeks
-builtins.int"builtins.int *(
-days
-builtins.int"builtins.int *)
-hours
-builtins.int"builtins.int *+
-minutes
-builtins.int"builtins.int *+
-seconds
-builtins.int"builtins.int *0
-milliseconds
-builtins.int"builtins.int *0
-microseconds
-builtins.int"builtins.int */
-nanoseconds
-builtins.int"builtins.int *(
-year
-builtins.int"builtins.int *)
-month
-builtins.int"builtins.int *'
-day
-builtins.int"builtins.int *+
-weekday
-builtins.int"builtins.int *(
-hour
-builtins.int"builtins.int **
-minute
-builtins.int"builtins.int **
-second
-builtins.int"builtins.int */
-microsecond
-builtins.int"builtins.int *.
-
-nanosecond
-builtins.int"builtins.int A
-
DatetimeIndex+pandas.core.indexes.datetimes.DatetimeIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"5pandas.core.indexes.accessors.DatetimeIndexProperties*
-__init__4pandas.core.indexes.datetimes.DatetimeIndex.__init__"
-None*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-data
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.tuple[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
-`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.IndexD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tuple*
-freq
-Any *
-tz
-Any */
-	normalize
-
builtins.bool"
builtins.bool *
-closed
-Any *-
-	ambiguous
-builtins.str"builtins.str *.
-dayfirst
-
builtins.bool"
builtins.bool */
-	yearfirst
-
builtins.bool"
builtins.bool *
-dtype
-Any **
-copy
-
builtins.bool"
builtins.bool *
-name
-Any *
-	__array__5pandas.core.indexes.datetimes.DatetimeIndex.__array__"9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-dtype
-Any *N
-
-__reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
-self*
-	to_series5pandas.core.indexes.datetimes.DatetimeIndex.to_series"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-keep_tz
-Any *
-index
-Any *
-name
-Any *
-snap0pandas.core.indexes.datetimes.DatetimeIndex.snap"
-Any*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*(
-freq
-builtins.str"builtins.str *a
-	get_value5pandas.core.indexes.datetimes.DatetimeIndex.get_value*
-self*
-
-series*
-key*b
-get_loc3pandas.core.indexes.datetimes.DatetimeIndex.get_loc*
-self*
-key*
-	tolerance *x
-
slice_indexer9pandas.core.indexes.datetimes.DatetimeIndex.slice_indexer*
-self*
-start *	
-end *
+None 0:typing.overloadX2<
+to_xml"pandas.core.frame.DataFrame.to_xml 
+to_xml"pandas.core.frame.DataFrame.to_xml"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buffer
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.bytes],pandas._typing.WriteBuffer[builtins.str]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathj
+*pandas._typing.WriteBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.WriteBufferd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer*+
+index
+
builtins.bool"
builtins.bool *-
+	root_name
+builtins.str"builtins.str *,
+row_name
+builtins.str"builtins.str *R
+na_repD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *
+	attr_cols
+4Union[builtins.list[pandas._typing.HashableT1],None]
+(builtins.list[pandas._typing.HashableT1]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
+	elem_cols
+4Union[builtins.list[pandas._typing.HashableT2],None]
+(builtins.list[pandas._typing.HashableT2]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
 
-step *
-searchsorted8pandas.core.indexes.datetimes.DatetimeIndex.searchsorted"
-Any*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-value
-Any*(
-side
-builtins.str"builtins.str *
-sorter
-Any *
-is_type_compatible>pandas.core.indexes.datetimes.DatetimeIndex.is_type_compatible"
-
builtins.bool"
builtins.bool*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-typ
-Any*
-
inferred_type9pandas.core.indexes.datetimes.DatetimeIndex.inferred_type"
-builtins.str"builtins.str*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`*Y
-insert2pandas.core.indexes.datetimes.DatetimeIndex.insert*
-self*
-loc*
-item*
-indexer_at_time;pandas.core.indexes.datetimes.DatetimeIndex.indexer_at_time"
-Any*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-time
-Any**
-asof
-
builtins.bool"
builtins.bool *
-indexer_between_time@pandas.core.indexes.datetimes.DatetimeIndex.indexer_between_time"
-Any*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+namespaces
+@Union[builtins.dict[Union[builtins.str,None],builtins.str],None]
+4builtins.dict[Union[builtins.str,None],builtins.str]D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None
+builtins.str"builtins.str"
builtins.dict
+None *R
+prefixD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+encoding
+builtins.str"builtins.str *5
+xml_declaration
+
builtins.bool"
builtins.bool *2
+pretty_print
+
builtins.bool"
builtins.bool *
+parser
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.XMLParsers *
 
-start_time
-Any*
-end_time
-Any*3
-
include_start
-
builtins.bool"
builtins.bool *1
-include_end
-
builtins.bool"
builtins.bool *
-to_perioddelta:pandas.core.indexes.datetimes.DatetimeIndex.to_perioddelta"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-freq
-Any*
-to_julian_date:pandas.core.indexes.datetimes.DatetimeIndex.to_julian_date"r
-.pandas.core.indexes.base.Index[builtins.float] 
-builtins.float"builtins.float"pandas.core.indexes.base.Index*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-isocalendar7pandas.core.indexes.datetimes.DatetimeIndex.isocalendar":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-tzinfo2pandas.core.indexes.datetimes.DatetimeIndex.tzinfo"M
-Union[datetime.tzinfo,None]"
-datetime.tzinfo"datetime.tzinfo
-None*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`*
-dtype1pandas.core.indexes.datetimes.DatetimeIndex.dtype"
-AUnion[numpy.dtype[Any],pandas.core.dtypes.dtypes.DatetimeTZDtype](
-numpy.dtype[Any]
-Any"numpy.dtypeV
-)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype*d
-selfZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`2
-__add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__
-__add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
-__add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-]Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX2
-__sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__
-__sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
-__sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-]Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX
-__sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-[Union[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX	
-DatetimeTZDtype)pandas.core.dtypes.dtypes.DatetimeTZDtype".pandas.core.dtypes.dtypes.PandasExtensionDtype*
-__init__2pandas.core.dtypes.dtypes.DatetimeTZDtype.__init__"
-None*`
-selfV
-)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype*C
-unit7
+stylesheet
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.str],pandas._typing.ReadBuffer[builtins.bytes],None]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathb
+'pandas._typing.ReadBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.ReadBufferh
+)pandas._typing.ReadBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer
+None *
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
 Literal[builtins.str]	
-builtins.str"builtins.str *
-tz
-5Union[builtins.str,builtins.int,datetime.tzinfo,None]
-builtins.str"builtins.str
-builtins.int"builtins.int"
-datetime.tzinfo"datetime.tzinfo
-None *
-unit.pandas.core.dtypes.dtypes.DatetimeTZDtype.unit"7
+builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str*`
-selfV
-)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype0:builtins.property`*
-tz,pandas.core.dtypes.dtypes.DatetimeTZDtype.tz""
-datetime.tzinfo"datetime.tzinfo*`
-selfV
-)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype0:builtins.property`*
-na_value2pandas.core.dtypes.dtypes.DatetimeTZDtype.na_value"J
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*`
-selfV
-)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype0:builtins.property`a
-Float32Dtype(pandas.core.arrays.floating.Float32Dtype"'pandas.core.arrays.numeric.NumericDtypea
-Float64Dtype(pandas.core.arrays.floating.Float64Dtype"'pandas.core.arrays.numeric.NumericDtype
-Grouper#pandas.core.groupby.grouper.Grouper"builtins.object*U
-__new__+pandas.core.groupby.grouper.Grouper.__new__*
-cls*
-args*
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions 0:typing.overloadX
+to_xml"pandas.core.frame.DataFrame.to_xml"
+builtins.str"builtins.str*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buffer
+None *+
+index
+
builtins.bool"
builtins.bool *U
+	root_nameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *T
+row_nameD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *R
+na_repD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *
+	attr_cols
+4Union[builtins.list[pandas._typing.HashableT1],None]
+(builtins.list[pandas._typing.HashableT1]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
+	elem_cols
+4Union[builtins.list[pandas._typing.HashableT2],None]
+(builtins.list[pandas._typing.HashableT2]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *
 
-kwargs*
-__init__,pandas.core.groupby.grouper.Grouper.__init__"
-None*T
-selfJ
-#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper*
-key
-Any *
-level
-Any *
-freq
-Any *(
-axis
-builtins.int"builtins.int **
-sort
-
builtins.bool"
builtins.bool *M
-ax&pandas.core.groupby.grouper.Grouper.ax*
-self0:builtins.property`*U
-groups*pandas.core.groupby.grouper.Grouper.groups*
-self0:builtins.property`rV
-key'pandas.core.groupby.grouper.Grouper.key&
-builtins.ellipsis"builtins.ellipsisrZ
-level)pandas.core.groupby.grouper.Grouper.level&
-builtins.ellipsis"builtins.ellipsisrX
-freq(pandas.core.groupby.grouper.Grouper.freq&
-builtins.ellipsis"builtins.ellipsisrX
-axis(pandas.core.groupby.grouper.Grouper.axis&
-builtins.ellipsis"builtins.ellipsisrX
-sort(pandas.core.groupby.grouper.Grouper.sort&
-builtins.ellipsis"builtins.ellipsisr^
-grouper+pandas.core.groupby.grouper.Grouper.grouper&
-builtins.ellipsis"builtins.ellipsisrV
-obj'pandas.core.groupby.grouper.Grouper.obj&
-builtins.ellipsis"builtins.ellipsisr^
-indexer+pandas.core.groupby.grouper.Grouper.indexer&
-builtins.ellipsis"builtins.ellipsisr\
-binner*pandas.core.groupby.grouper.Grouper.binner&
-builtins.ellipsis"builtins.ellipsisف
-Indexpandas.core.indexes.base.Index"pandas.core.base.IndexOpsMixin*1
-str"pandas.core.indexes.base.Index.str"
-kpandas.core.strings.StringMethods[pandas.core.indexes.base.Index.Self,pandas.core.indexes.multi.MultiIndex]
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(L
-$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex"!pandas.core.strings.StringMethods*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(0:builtins.property`*
-asi8#pandas.core.indexes.base.Index.asi8"
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_int64*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
-is_"pandas.core.indexes.base.Index.is_"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-other
-Any*
-__len__&pandas.core.indexes.base.Index.__len__"
-builtins.int"builtins.int*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-	__array__(pandas.core.indexes.base.Index.__array__"9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-dtype
-Any *d
-__array_wrap__-pandas.core.indexes.base.Index.__array_wrap__*
-self*
+namespaces
+@Union[builtins.dict[Union[builtins.str,None],builtins.str],None]
+4builtins.dict[Union[builtins.str,None],builtins.str]D
+Union[builtins.str,None]
+builtins.str"builtins.str
+None
+builtins.str"builtins.str"
builtins.dict
+None *R
+prefixD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *,
+encoding
+builtins.str"builtins.str *^
+xml_declarationG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *[
+pretty_printG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *R
+parserD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *
 
-result*
-context *
-dtype$pandas.core.indexes.base.Index.dtype"
-STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
-HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtypeP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
-ravel$pandas.core.indexes.base.Index.ravel"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*)
-order
-builtins.str"builtins.str *@
-view#pandas.core.indexes.base.Index.view*
-self*	
-cls *&
-astype%pandas.core.indexes.base.Index.astype"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+stylesheet
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.str],pandas._typing.ReadBuffer[builtins.bytes],None]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathb
+'pandas._typing.ReadBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.ReadBufferh
+)pandas._typing.ReadBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer
+None *
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions 0:typing.overloadX2
+__getitem__'pandas.core.frame.DataFrame.__getitem__
+__getitem__'pandas.core.frame.DataFrame.__getitem__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*<:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],builtins.tuple[typing.Hashable]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+
datetime.date"
datetime.date&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-dtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
-Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype8
-typing.Mapping[Any,Unknown]
-Any"typing.Mapping"pandas._typing.DtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-take#pandas.core.indexes.base.Index.take"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-indices
-Any*(
-axis
-builtins.int"builtins.int *0
-
-allow_fill
-
builtins.bool"
builtins.bool *
-
-fill_value
-Any *
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.ScalarU
+builtins.tuple[typing.Hashable]"
+typing.Hashable"typing.Hashable"builtins.tuple0:typing.overloadX
+__getitem__'pandas.core.frame.DataFrame.__getitem__":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*<:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+6Union[typing.Iterable[typing.Hashable],builtins.slice]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable 
+builtins.slice"builtins.slice0:typing.overloadX
+__getitem__'pandas.core.frame.DataFrame.__getitem__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*<:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*$"
+typing.Hashable"typing.Hashable0:typing.overloadX2
+query!pandas.core.frame.DataFrame.query
+query!pandas.core.frame.DataFrame.query"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*&
+expr
+builtins.str"builtins.str*G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
 kwargs
-Any*R
-repeat%pandas.core.indexes.base.Index.repeat*
-self*
-repeats*
-
-axis *0
-copy#pandas.core.indexes.base.Index.copy"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
+Any0:typing.overloadX
+query!pandas.core.frame.DataFrame.query":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*&
+expr
+builtins.str"builtins.str*I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX2 
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes"
+NoReturn
+*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*	
+include	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
 Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-name
-Any **
-deep
-
builtins.bool"
builtins.bool *I
-__copy__'pandas.core.indexes.base.Index.__copy__*
-self*
-
-kwargs*Q
-__deepcopy__+pandas.core.indexes.base.Index.__deepcopy__*
-self*
-
-memo *
-format%pandas.core.indexes.base.Index.format"J
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index**
-name
-
builtins.bool"
builtins.bool *
-	formatter
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None **
-na_rep
-builtins.str"builtins.str *e
-to_native_types.pandas.core.indexes.base.Index.to_native_types*
-self*
-slicer *
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
 
-kwargs*G
-
to_flat_index,pandas.core.indexes.base.Index.to_flat_index*
-self*
-	to_series(pandas.core.indexes.base.Index.to_series"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-index
-Any *
-name
-Any *
-to_frame'pandas.core.indexes.base.Index.to_frame":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg*
+exclude
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]],None]
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
 Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*+
-index
-
builtins.bool"
builtins.bool *
-name
-Any *
-	set_names(pandas.core.indexes.base.Index.set_names"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
 Type[builtins.str]
-builtins.str"builtins.str"typeF
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
 Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-names
-Any*
-level
-Any *-
-inplace
-
builtins.bool"
builtins.bool *
-rename%pandas.core.indexes.base.Index.rename"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList
+None 0:typing.overloadX
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes"
+NoReturn
+*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+include
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]],None]
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList
+None*	
+exclude	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg0:typing.overloadX
+
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes"
+NoReturn
+*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*	
+exclude	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg0:typing.overloadX
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes"
+NoReturn
+*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
+include6
+builtins.list[NoReturn]
+NoReturn
+"
builtins.list*C
+exclude6
+builtins.list[NoReturn]
+NoReturn
+"
builtins.list0:typing.overloadX	
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*ŵ
+include
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList*
+exclude
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]],None]
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList
+None 0:typing.overloadX	
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+include
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]],None]
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList
+None*ŵ
+exclude
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList0:typing.overloadX
+
select_dtypes)pandas.core.frame.DataFrame.select_dtypes":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*ŵ
+exclude
+6TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]]
+6Union[TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],builtins.list[Unknown]]
+5TypeAlias[Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+5Union[TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+4TypeAlias[Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]]
+4Union[TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]],TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
+
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArg
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj"pandas._typing.AstypeArg7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"(pandas.core.frame.DataFrame.AstypeArgExt)
+builtins.list[Unknown]"
builtins.list",pandas.core.frame.DataFrame.AstypeArgExtList0:typing.overloadX2^
+rename"pandas.core.frame.DataFrame.rename
+rename"pandas.core.frame.DataFrame.rename"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+index
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+columns
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+rename"pandas.core.frame.DataFrame.rename":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+index
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+columns
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+rename"pandas.core.frame.DataFrame.rename"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+index
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+columns
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *-
+inplace
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2[
+fillna"pandas.core.frame.DataFrame.fillna
+fillna"pandas.core.frame.DataFrame.fillna"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dictD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *)
+limit
+builtins.int"builtins.int *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX
+fillna"pandas.core.frame.DataFrame.fillna":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dictD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *)
+limit
+builtins.int"builtins.int *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+fillna"pandas.core.frame.DataFrame.fillna"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dictD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *)
+limit
+builtins.int"builtins.int *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2J
+replace#pandas.core.frame.DataFrame.replace
+replace#pandas.core.frame.DataFrame.replace"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+
+to_replace
+Any *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,typing.Sequence[Any],typing.Mapping[Any,Any],re.Pattern[Any],None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType0
+typing.Sequence[Any]
+Any"typing.Sequence;
+typing.Mapping[Any,Any]
+Any
+Any"typing.Mapping&
+re.Pattern[Any]
+Any"
+re.Pattern
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX
+replace#pandas.core.frame.DataFrame.replace":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+
+to_replace
+Any *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,typing.Sequence[Any],typing.Mapping[Any,Any],re.Pattern[Any],None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType0
+typing.Sequence[Any]
+Any"typing.Sequence;
+typing.Mapping[Any,Any]
+Any
+Any"typing.Mapping&
+re.Pattern[Any]
+Any"
+re.Pattern
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX
+replace#pandas.core.frame.DataFrame.replace"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+
+to_replace
+Any *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,typing.Sequence[Any],typing.Mapping[Any,Any],re.Pattern[Any],None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType0
+typing.Sequence[Any]
+Any"typing.Sequence;
+typing.Mapping[Any,Any]
+Any
+Any"typing.Mapping&
+re.Pattern[Any]
+Any"
+re.Pattern
+None *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX2
+	set_index%pandas.core.frame.DataFrame.set_index	
+	set_index%pandas.core.frame.DataFrame.set_index"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+keys
+Union[TypeAlias[Union[typing.Hashable,None]],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],typing.Iterator[pandas._typing.HashableT],builtins.list[pandas._typing.HashableT]]
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.LabelD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+)typing.Iterator[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Iterator
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list**
+drop
+
builtins.bool"
builtins.bool *,
+append
+
builtins.bool"
builtins.bool *6
+verify_integrity
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX
+
+	set_index%pandas.core.frame.DataFrame.set_index":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+keys
+Union[TypeAlias[Union[typing.Hashable,None]],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],typing.Iterator[pandas._typing.HashableT],builtins.list[pandas._typing.HashableT]]
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.LabelD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+)typing.Iterator[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Iterator
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list**
+drop
+
builtins.bool"
builtins.bool *,
+append
+
builtins.bool"
builtins.bool *6
+verify_integrity
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+reset_index'pandas.core.frame.DataFrame.reset_index
+reset_index'pandas.core.frame.DataFrame.reset_index"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level-
+typing.Sequence[Unknown]"typing.Sequence **
+drop
+
builtins.bool"
builtins.bool *q
+	col_level`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str *2
+col_fill"
+typing.Hashable"typing.Hashable *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*6
+allow_duplicates
+
builtins.bool"
builtins.bool *
+names
+>Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
+typing.Hashable"typing.Hashable
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX
+reset_index'pandas.core.frame.DataFrame.reset_index":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level-
+typing.Sequence[Unknown]"typing.Sequence *q
+	col_level`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str *2
+col_fill"
+typing.Hashable"typing.Hashable **
+drop
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *6
+allow_duplicates
+
builtins.bool"
builtins.bool *
+names
+>Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
+typing.Hashable"typing.Hashable
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX	
+reset_index'pandas.core.frame.DataFrame.reset_index"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+NUnion[TypeAlias[Union[typing.Hashable,builtins.int]],typing.Sequence[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level-
+typing.Sequence[Unknown]"typing.Sequence **
+drop
+
builtins.bool"
builtins.bool *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *q
+	col_level`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str *2
+col_fill"
+typing.Hashable"typing.Hashable *6
+allow_duplicates
+
builtins.bool"
builtins.bool *
+names
+>Union[typing.Hashable,builtins.list[pandas._typing.HashableT]]"
+typing.Hashable"typing.Hashable
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list 0:typing.overloadX2`
+dropna"pandas.core.frame.DataFrame.dropna
+dropna"pandas.core.frame.DataFrame.dropna"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+how
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *R
+threshD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+subset
+Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
+TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
+uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
+typing.Sequence[Any]
+Any"typing.Sequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX 
+dropna"pandas.core.frame.DataFrame.dropna":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+how
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *R
+threshD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+subset
+Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
+TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
+uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
+typing.Sequence[Any]
+Any"typing.Sequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX 
+dropna"pandas.core.frame.DataFrame.dropna"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+how
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *R
+threshD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+subset
+Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
+TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
+uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
+typing.Sequence[Any]
+Any"typing.Sequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+None *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None 0:typing.overloadX2:
+sort_values'pandas.core.frame.DataFrame.sort_values
+sort_values'pandas.core.frame.DataFrame.sort_values"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+1Union[builtins.str,typing.Sequence[builtins.str]]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *2
+ignore_index
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX
+sort_values'pandas.core.frame.DataFrame.sort_values":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+1Union[builtins.str,typing.Sequence[builtins.str]]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *2
+ignore_index
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX
+sort_values'pandas.core.frame.DataFrame.sort_values"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+1Union[builtins.str,typing.Sequence[builtins.str]]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *2
+ignore_index
+
builtins.bool"
builtins.bool *
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX2A
+
+sort_index&pandas.core.frame.DataFrame.sort_index
+
+sort_index&pandas.core.frame.DataFrame.sort_index"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *4
+sort_remaining
+
builtins.bool"
builtins.bool *2
+ignore_index
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX
+
+sort_index&pandas.core.frame.DataFrame.sort_index":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+level
+rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.LevelJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.listJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list
+None *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *4
+sort_remaining
+
builtins.bool"
builtins.bool *2
+ignore_index
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX
+
+sort_index&pandas.core.frame.DataFrame.sort_index"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+level
+rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.LevelJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.listJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list
+None *
+	ascending
+3Union[builtins.bool,typing.Sequence[builtins.bool]]
+
builtins.bool"
builtins.boolQ
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequence *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+kind
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.SortKind *
+na_position
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition *4
+sort_remaining
+
builtins.bool"
builtins.bool *2
+ignore_index
+
builtins.bool"
builtins.bool *
+key
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None 0:typing.overloadX2
+
+value_counts(pandas.core.frame.DataFrame.value_counts
+value_counts(pandas.core.frame.DataFrame.value_counts"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+subset
+,Union[typing.Sequence[typing.Hashable],None]W
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence
+None *K
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+value_counts(pandas.core.frame.DataFrame.value_counts"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*I
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+subset
+,Union[typing.Sequence[typing.Hashable],None]W
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence
+None **
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+groupby#pandas.core.frame.DataFrame.groupby*
+groupby#pandas.core.frame.DataFrame.groupby"
+pandas.core.groupby.generic.DataFrameGroupBy[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"
+Vpandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.timestamps.Timestamp]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*b
+byZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"
+Vpandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*f
+by^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"
+Opandas.core.groupby.generic.DataFrameGroupBy[pandas._libs.tslibs.period.Period]F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*X
+byP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"
+Fpandas.core.groupby.generic.DataFrameGroupBy[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
+pandas._typing.IntervalTN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX'
+groupby#pandas.core.frame.DataFrame.groupby"
+Apandas.core.groupby.generic.DataFrameGroupBy[builtins.tuple[Any]].
+builtins.tuple[Any]
+Any"builtins.tuple",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+Union[pandas.core.indexes.multi.MultiIndex,TypeAlias[Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]]],None]L
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex
+TypeAlias[Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]]]
+Union[builtins.tuple[Any],builtins.list[pandas._typing._HashableTa],TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]],builtins.list[Unknown],builtins.list[pandas.core.series.Series[Any]],numpy.ndarray[Any,Any],builtins.list[numpy.ndarray[Any,Any]],typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any],builtins.list[typing.Mapping[Unknown,Any]],builtins.list[pandas.core.indexes.base.Index[Any]],pandas.core.groupby.grouper.Grouper,builtins.list[pandas.core.groupby.grouper.Grouper]].
+builtins.tuple[Any]
+Any"builtins.tuple
+)builtins.list[pandas._typing._HashableTa]S
+pandas._typing._HashableTa"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+=TypeAlias[Union[numpy.ufunc,CallableType[builtins.function]]]
+2Union[numpy.ufunc,CallableType[builtins.function]]
+numpy.ufunc"numpy.ufuncK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Function)
+builtins.list[Unknown]"
builtins.list
+-builtins.list[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series"
builtins.list9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayq
+%builtins.list[numpy.ndarray[Any,Any]]9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.list
+:typing.Mapping[TypeAlias[Union[typing.Hashable,None]],Any]
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label
+Any"typing.Mappingu
+*builtins.list[typing.Mapping[Unknown,Any]]8
+typing.Mapping[Unknown,Any]
+Any"typing.Mapping"
builtins.list
+2builtins.list[pandas.core.indexes.base.Index[Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"
builtins.listJ
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper
+2builtins.list[pandas.core.groupby.grouper.Grouper]J
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"
builtins.list"%pandas._typing.GroupByObjectNonScalar
+None *
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX"
+groupby#pandas.core.frame.DataFrame.groupby"
+Fpandas.core.groupby.generic.DataFrameGroupBy[pandas._typing.SeriesByT]
+
+pandas._typing.SeriesByT	
+Union[builtins.str,builtins.bytes,datetime.date,builtins.bool,builtins.int,builtins.float,builtins.complex,datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
+pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+
+by
+
+3pandas.core.series.Series[pandas._typing.SeriesByT]
+
+pandas._typing.SeriesByT	
+Union[builtins.str,builtins.bytes,datetime.date,builtins.bool,builtins.int,builtins.float,builtins.complex,datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
+pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"pandas.core.series.Series*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+groupby#pandas.core.frame.DataFrame.groupby"j
+1pandas.core.groupby.generic.DataFrameGroupBy[Any]
+Any",pandas.core.groupby.generic.DataFrameGroupBy*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+by
+|Union[pandas.core.indexes.category.CategoricalIndex[Any],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any]]l
+2pandas.core.indexes.category.CategoricalIndex[Any]
+Any"-pandas.core.indexes.category.CategoricalIndexN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+axis
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+level
+NUnion[TypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]],None]
+BTypeAlias[Union[typing.Hashable,typing.Sequence[typing.Hashable]]]
+7Union[typing.Hashable,typing.Sequence[typing.Hashable]]"
+typing.Hashable"typing.HashableW
+ typing.Sequence[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Sequence"pandas._typing.IndexLabel
+None *.
+as_index
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *0
+
+group_keys
+
builtins.bool"
builtins.bool *
+observed
+DUnion[builtins.bool,TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+
builtins.bool"
builtins.bool
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+stack!pandas.core.frame.DataFrame.stack
+stack!pandas.core.frame.DataFrame.stack"
+AUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any]]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level)
+builtins.list[Unknown]"
builtins.list *,
+dropna
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool 0:typing.overloadX
+stack!pandas.core.frame.DataFrame.stack"
+AUnion[pandas.core.frame.DataFrame,pandas.core.series.Series[Any]]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+level
+LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level)
+builtins.list[Unknown]"
builtins.list *2
+future_stack
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+aggpandas.core.frame.DataFrame.agg
+aggpandas.core.frame.DataFrame.agg"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+func
+Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase
+;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
+0typing.Mapping[pandas._typing.HashableT,Unknown]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+kwargs
+Any0:typing.overloadX
+aggpandas.core.frame.DataFrame.agg":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+func
+Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
+Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
+YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
+Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.HashableV
+%Union[Unknown,builtins.list[Unknown]])
+builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+kwargs
+Any0:typing.overloadX2
+	aggregate%pandas.core.frame.DataFrame.aggregate
+	aggregate%pandas.core.frame.DataFrame.aggregate"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+func
+Union[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase
+;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
+0typing.Mapping[pandas._typing.HashableT,Unknown]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+kwargs
+Any0:typing.overloadX
+	aggregate%pandas.core.frame.DataFrame.aggregate":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+func
+Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
+Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
+YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
+Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.HashableV
+%Union[Unknown,builtins.list[Unknown]])
+builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+kwargs
+Any0:typing.overloadX2
+apply!pandas.core.frame.DataFrame.apply
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *
+result_type
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+
+apply!pandas.core.frame.DataFrame.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*)
+raw
+
builtins.bool"
builtins.bool *
+result_type
+None *
+args
+Any *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn*
+kwargs
+Any0:typing.overloadX
+apply!pandas.core.frame.DataFrame.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*R
+fK
+CallableType[builtins.function]&
+builtins.function"builtins.function*)
+raw
+
builtins.bool"
builtins.bool *
+args
+Any *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn*H
+result_type7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+kwargs
+Any0:typing.overloadX2
+count!pandas.core.frame.DataFrame.count
+
+count!pandas.core.frame.DataFrame.count":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
+numeric_only
+
builtins.bool"
builtins.bool *
+level
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level0:typing.overloadX
+count!pandas.core.frame.DataFrame.count"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool 0:typing.overloadX2
+mode pandas.core.frame.DataFrame.mode
+
+mode pandas.core.frame.DataFrame.mode":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *,
+skipna
+
builtins.bool"
builtins.bool *2
+numeric_only
+
builtins.bool"
builtins.bool *
+level
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level*
+kwargs
+Any0:typing.overloadX	
+mode pandas.core.frame.DataFrame.mode"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX2!
+quantile$pandas.core.frame.DataFrame.quantile
+quantile$pandas.core.frame.DataFrame.quantile"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*)
+q 
+builtins.float"builtins.float *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
+numeric_only
+
builtins.bool"
builtins.bool *
+
interpolation
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod 0:typing.overloadX
+quantile$pandas.core.frame.DataFrame.quantile":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+q
+;Union[builtins.list[builtins.float],numpy.ndarray[Any,Any]]P
+builtins.list[builtins.float] 
+builtins.float"builtins.float"
builtins.list9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *2
+numeric_only
+
builtins.bool"
builtins.bool *
+
interpolation
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"$pandas._typing.QuantileInterpolation *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod 0:typing.overloadX2
+
+columns#pandas.core.frame.DataFrame.columns
+columns#pandas.core.frame.DataFrame.columns"l
+,pandas.core.indexes.base.Index[builtins.str]
+builtins.str"builtins.str"pandas.core.indexes.base.Index*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame0:builtins.propertyX`
+columns#pandas.core.frame.DataFrame.columns"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+cols
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[pandas._typing.HashableT],builtins.tuple[pandas._typing.HashableT]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple0:.setter2
+index!pandas.core.frame.DataFrame.index
+index!pandas.core.frame.DataFrame.index"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame0:builtins.propertyX`
+index!pandas.core.frame.DataFrame.index"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*W
+idxN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index0:.setter2
+allpandas.core.frame.DataFrame.all
+allpandas.core.frame.DataFrame.all"
+
builtins.bool"
builtins.bool*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+None*X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX	
+allpandas.core.frame.DataFrame.all"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX2
+anypandas.core.frame.DataFrame.any
+anypandas.core.frame.DataFrame.any"
+
builtins.bool"
builtins.bool*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+None*X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX	
+anypandas.core.frame.DataFrame.any"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX2
+bfill!pandas.core.frame.DataFrame.bfill
+bfill!pandas.core.frame.DataFrame.bfill"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX
+bfill!pandas.core.frame.DataFrame.bfill":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2
+ffill!pandas.core.frame.DataFrame.ffill
+ffill!pandas.core.frame.DataFrame.ffill"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX
+ffill!pandas.core.frame.DataFrame.ffill":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2
+getpandas.core.frame.DataFrame.get
+getpandas.core.frame.DataFrame.get"~
+*Union[pandas.core.series.Series[Any],None]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*+
+key"
+typing.Hashable"typing.Hashable*
+default
+None 0:typing.overloadX
+getpandas.core.frame.DataFrame.get"
+6Union[pandas.core.series.Series[Any],pandas._typing.T]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*+
+key"
+typing.Hashable"typing.Hashable*V
+defaultI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object0:typing.overloadX
+getpandas.core.frame.DataFrame.get"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*\
+keyS
+builtins.list[typing.Hashable]"
+typing.Hashable"typing.Hashable"
builtins.list*
+default
+None 0:typing.overloadX
+getpandas.core.frame.DataFrame.get"
+3Union[pandas.core.frame.DataFrame,pandas._typing.T]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*\
+keyS
+builtins.list[typing.Hashable]"
+typing.Hashable"typing.Hashable"
builtins.list*V
+defaultI
+pandas._typing.T"
+builtins.object"builtins.object"builtins.object0:typing.overloadX2X
+interpolate'pandas.core.frame.DataFrame.interpolate
+interpolate'pandas.core.frame.DataFrame.interpolate"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+method
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+limit_direction
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+
+limit_area
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *x
+downcasth
+!Union[Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+kwargs
+Any0:typing.overloadX
+interpolate'pandas.core.frame.DataFrame.interpolate":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+method
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+limit_direction
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+
+limit_area
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *x
+downcasth
+!Union[Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+kwargs
+Any0:typing.overloadX
+interpolate'pandas.core.frame.DataFrame.interpolate"q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+method
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *V
+inplaceG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+limit_direction
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+
+limit_area
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *x
+downcasth
+!Union[Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+kwargs
+Any0:typing.overloadX2,
+rename_axis'pandas.core.frame.DataFrame.rename_axis
+
+rename_axis'pandas.core.frame.DataFrame.rename_axis"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+Any *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadX
+
+rename_axis'pandas.core.frame.DataFrame.rename_axis":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+mapper
+Any *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+rename_axis'pandas.core.frame.DataFrame.rename_axis"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+index
+Union[builtins.str,typing.Sequence[builtins.str],builtins.dict[Union[builtins.str,builtins.int],builtins.str],CallableType[builtins.function],None]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+pandas.core.window.rolling.Window[pandas.core.frame.DataFrame]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"!pandas.core.window.rolling.Window*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+window
+{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
+builtins.int"builtins.int
+builtins.str"builtins.str(
+datetime.timedelta"datetime.timedeltaP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
+ pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
+min_periodsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+center
+
builtins.bool"
builtins.bool *W
+onM
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+closed
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType
+None *P
+stepD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod **
+win_type
+builtins.str"builtins.str0:typing.overloadX
+rolling#pandas.core.frame.DataFrame.rolling"
+?pandas.core.window.rolling.Rolling[pandas.core.frame.DataFrame]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame""pandas.core.window.rolling.Rolling*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+window
+{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
+builtins.int"builtins.int
+builtins.str"builtins.str(
+datetime.timedelta"datetime.timedeltaP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
+ pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
+min_periodsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+center
+
builtins.bool"
builtins.bool *W
+onM
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+closed
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType
+None *P
+stepD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod *
+win_type
+None 0:typing.overloadX2`
+to_json#pandas.core.frame.DataFrame.to_json
+to_json#pandas.core.frame.DataFrame.to_json"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buf
+hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer*C
+orient7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+date_format
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *4
+double_precision
+builtins.int"builtins.int *1
+force_ascii
+
builtins.bool"
builtins.bool *
+	date_unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit *
+default_handler
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *E
+lines:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
+index
+
builtins.bool"
builtins.bool *R
+indentD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *A
+mode7
+Literal[builtins.str]	
+builtins.str"builtins.str0:typing.overloadX
+to_json#pandas.core.frame.DataFrame.to_json"
+builtins.str"builtins.str*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buf
+None *C
+orient7
+Literal[builtins.str]	
+builtins.str"builtins.str*
+date_format
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *4
+double_precision
+builtins.int"builtins.int *1
+force_ascii
+
builtins.bool"
builtins.bool *
+	date_unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit *
+default_handler
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *E
+lines:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
+index
+
builtins.bool"
builtins.bool *R
+indentD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *A
+mode7
+Literal[builtins.str]	
+builtins.str"builtins.str0:typing.overloadX
+to_json#pandas.core.frame.DataFrame.to_json"
+builtins.str"builtins.str*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buf
+None *
+orient
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.JsonFrameOrient
+None *
+date_format
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *4
+double_precision
+builtins.int"builtins.int *1
+force_ascii
+
builtins.bool"
builtins.bool *
+	date_unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit *
+default_handler
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *+
+lines
+
builtins.bool"
builtins.bool *
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
+index
+
builtins.bool"
builtins.bool *R
+indentD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *C
+mode7
+Literal[builtins.str]	
+builtins.str"builtins.str 0:typing.overloadX
+to_json#pandas.core.frame.DataFrame.to_json"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+path_or_buf
+hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer*
+orient
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.JsonFrameOrient
+None *
+date_format
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *4
+double_precision
+builtins.int"builtins.int *1
+force_ascii
+
builtins.bool"
builtins.bool *
+	date_unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit *
+default_handler
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *+
+lines
+
builtins.bool"
builtins.bool *
+compression
+TypeAlias[Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]]
+Union[None,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],TypeAlias[builtins.dict[builtins.str,Any]]]
+None7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+*TypeAlias[builtins.dict[builtins.str,Any]]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict"pandas._typing.CompressionDict"!pandas._typing.CompressionOptions *+
+index
+
builtins.bool"
builtins.bool *R
+indentD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *C
+mode7
+Literal[builtins.str]	
+builtins.str"builtins.str 0:typing.overloadX2;
+	to_string%pandas.core.frame.DataFrame.to_string 
+	to_string%pandas.core.frame.DataFrame.to_string"
+None*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+buf
+hUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.WriteBuffer[builtins.str]]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathd
+(pandas._typing.WriteBuffer[builtins.str]
+builtins.str"builtins.str"pandas._typing.WriteBuffer*
+columns
+wUnion[builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
+(builtins.list[pandas._typing.HashableT1]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None *
+	col_space
+jUnion[builtins.int,builtins.list[builtins.int],builtins.dict[pandas._typing.HashableT2,builtins.int],None]
+builtins.int"builtins.intJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+5builtins.dict[pandas._typing.HashableT2,builtins.int]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable
+builtins.int"builtins.int"
builtins.dict
+None *
+header
+MUnion[builtins.bool,builtins.list[builtins.str],builtins.tuple[builtins.str]]
+
builtins.bool"
builtins.boolJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.listL
+builtins.tuple[builtins.str]
+builtins.str"builtins.str"builtins.tuple *+
+index
+
builtins.bool"
builtins.bool **
+na_rep
+builtins.str"builtins.str *	
+
+formatters	
+Union[TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]],None]
+TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]]
+Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]
+.builtins.list[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"
builtins.list
+/builtins.tuple[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"builtins.tuple
+Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.intK
+CallableType[builtins.function]&
+builtins.function"builtins.function"typing.Mapping"pandas._typing.FormattersType
+None *
+float_format
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *W
+sparsifyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *1
+index_names
+
builtins.bool"
builtins.bool *S
+justifyD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *T
+max_rowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+max_colsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *5
+show_dimensions
+
builtins.bool"
builtins.bool *+
+decimal
+builtins.str"builtins.str *V
+
+line_widthD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+min_rowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *X
+max_colwidthD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+encodingD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None 0:typing.overloadX
+	to_string%pandas.core.frame.DataFrame.to_string"
+builtins.str"builtins.str*D
+self:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+buf
+None *
+columns
+vUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],None]
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None *
+	col_space
+`Union[builtins.int,builtins.list[builtins.int],builtins.dict[typing.Hashable,builtins.int],None]
+builtins.int"builtins.intJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list~
++builtins.dict[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"
builtins.dict
+None *
+header
+2Union[builtins.bool,typing.Sequence[builtins.str]]
+
builtins.bool"
builtins.boolN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence *+
+index
+
builtins.bool"
builtins.bool **
+na_rep
+builtins.str"builtins.str *	
+
+formatters	
+Union[TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]],None]
+TypeAlias[Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]]
+Union[builtins.list[CallableType[builtins.function]],builtins.tuple[CallableType[builtins.function]],typing.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]]
+.builtins.list[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"
builtins.list
+/builtins.tuple[CallableType[builtins.function]]K
+CallableType[builtins.function]&
+builtins.function"builtins.function"builtins.tuple
+Ptyping.Mapping[Union[builtins.str,builtins.int],CallableType[builtins.function]]`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.intK
+CallableType[builtins.function]&
+builtins.function"builtins.function"typing.Mapping"pandas._typing.FormattersType
+None *
+float_format
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *W
+sparsifyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *1
+index_names
+
builtins.bool"
builtins.bool *S
+justifyD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *T
+max_rowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+max_colsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *5
+show_dimensions
+
builtins.bool"
builtins.bool *+
+decimal
+builtins.str"builtins.str *V
+
+line_widthD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+min_rowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *X
+max_colwidthD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *T
+encodingD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None 0:typing.overloadXr:
+__hash__$pandas.core.frame.DataFrame.__hash__
+NonerT
+sparse"pandas.core.frame.DataFrame.sparse&
+builtins.ellipsis"builtins.ellipsisrF
+Name pandas.core.frame.DataFrame.Name
+builtins.str"builtins.str	
+
+DateOffset&pandas._libs.tslibs.offsets.DateOffset"/pandas._libs.tslibs.offsets.RelativeDeltaOffset*
+__init__/pandas._libs.tslibs.offsets.DateOffset.__init__"
+None*Z
+selfP
+&pandas._libs.tslibs.offsets.DateOffset"&pandas._libs.tslibs.offsets.DateOffset*%
+n
+builtins.int"builtins.int */
+	normalize
+
builtins.bool"
builtins.bool *)
+years
+builtins.int"builtins.int **
+months
+builtins.int"builtins.int *)
+weeks
+builtins.int"builtins.int *(
+days
+builtins.int"builtins.int *)
+hours
+builtins.int"builtins.int *+
+minutes
+builtins.int"builtins.int *+
+seconds
+builtins.int"builtins.int *0
+milliseconds
+builtins.int"builtins.int *0
+microseconds
+builtins.int"builtins.int */
+nanoseconds
+builtins.int"builtins.int *(
+year
+builtins.int"builtins.int *)
+month
+builtins.int"builtins.int *'
+day
+builtins.int"builtins.int *Q
+weekdayB
+Union[builtins.int,Any]
+builtins.int"builtins.int
+Any *(
+hour
+builtins.int"builtins.int **
+minute
+builtins.int"builtins.int **
+second
+builtins.int"builtins.int */
+microsecond
+builtins.int"builtins.int *.
+
+nanosecond
+builtins.int"builtins.int >
+
DatetimeIndex+pandas.core.indexes.datetimes.DatetimeIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"5pandas.core.indexes.accessors.DatetimeIndexProperties*
+__init__4pandas.core.indexes.datetimes.DatetimeIndex.__init__"
+None*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+data
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.tuple[Any]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list.
+builtins.tuple[Any]
+Any"builtins.tuple*
+freq
+Any *
+tz
+Any *-
+	ambiguous
+builtins.str"builtins.str *.
+dayfirst
+
builtins.bool"
builtins.bool */
+	yearfirst
+
builtins.bool"
builtins.bool *
+dtype
+Any **
+copy
+
builtins.bool"
builtins.bool *
+name
+Any *
+	__array__5pandas.core.indexes.datetimes.DatetimeIndex.__array__"9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+dtype
+Any *N
+
+__reduce__6pandas.core.indexes.datetimes.DatetimeIndex.__reduce__*
+self*
+	to_series5pandas.core.indexes.datetimes.DatetimeIndex.to_series"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+index
+Any *
+name
+Any *
+snap0pandas.core.indexes.datetimes.DatetimeIndex.snap"
+Any*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*(
+freq
+builtins.str"builtins.str *x
+
slice_indexer9pandas.core.indexes.datetimes.DatetimeIndex.slice_indexer*
+self*
+start *	
+end *
+
+step *
+searchsorted8pandas.core.indexes.datetimes.DatetimeIndex.searchsorted"
+Any*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+value
+Any*(
+side
+builtins.str"builtins.str *
+sorter
+Any *
+
inferred_type9pandas.core.indexes.datetimes.DatetimeIndex.inferred_type"
+builtins.str"builtins.str*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`*Y
+insert2pandas.core.indexes.datetimes.DatetimeIndex.insert*
+self*
+loc*
+item*
+indexer_at_time;pandas.core.indexes.datetimes.DatetimeIndex.indexer_at_time"
+Any*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+time
+Any**
+asof
+
builtins.bool"
builtins.bool *
+indexer_between_time@pandas.core.indexes.datetimes.DatetimeIndex.indexer_between_time"
+Any*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+
+start_time
+Any*
+end_time
+Any*3
+
include_start
+
builtins.bool"
builtins.bool *1
+include_end
+
builtins.bool"
builtins.bool *
+to_julian_date:pandas.core.indexes.datetimes.DatetimeIndex.to_julian_date"r
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+isocalendar7pandas.core.indexes.datetimes.DatetimeIndex.isocalendar":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+tzinfo2pandas.core.indexes.datetimes.DatetimeIndex.tzinfo"M
+Union[datetime.tzinfo,None]"
+datetime.tzinfo"datetime.tzinfo
+None*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`*
+dtype1pandas.core.indexes.datetimes.DatetimeIndex.dtype"
+AUnion[numpy.dtype[Any],pandas.core.dtypes.dtypes.DatetimeTZDtype](
+numpy.dtype[Any]
+Any"numpy.dtypeV
+)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype*d
+selfZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:builtins.property`2
+__add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__
+__add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+__add__3pandas.core.indexes.datetimes.DatetimeIndex.__add__"Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+Union[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.offsets.BaseOffset](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX2
+__sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__
+__sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*\Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*JH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+__sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*\Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+Union[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.offsets.BaseOffset](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset0:typing.overloadX
+__sub__3pandas.core.indexes.datetimes.DatetimeIndex.__sub__"^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*\Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+mUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]&
+datetime.datetime"datetime.datetimeT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampZ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX	
+DatetimeTZDtype)pandas.core.dtypes.dtypes.DatetimeTZDtype".pandas.core.dtypes.dtypes.PandasExtensionDtype*
+__init__2pandas.core.dtypes.dtypes.DatetimeTZDtype.__init__"
+None*`
+selfV
+)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype*C
+unit7
+Literal[builtins.str]	
+builtins.str"builtins.str *
+tz
+5Union[builtins.str,builtins.int,datetime.tzinfo,None]
+builtins.str"builtins.str
+builtins.int"builtins.int"
+datetime.tzinfo"datetime.tzinfo
+None *
+unit.pandas.core.dtypes.dtypes.DatetimeTZDtype.unit"7
+Literal[builtins.str]	
+builtins.str"builtins.str*`
+selfV
+)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype0:builtins.property`*
+tz,pandas.core.dtypes.dtypes.DatetimeTZDtype.tz""
+datetime.tzinfo"datetime.tzinfo*`
+selfV
+)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype0:builtins.property`*
+na_value2pandas.core.dtypes.dtypes.DatetimeTZDtype.na_value"J
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*`
+selfV
+)pandas.core.dtypes.dtypes.DatetimeTZDtype")pandas.core.dtypes.dtypes.DatetimeTZDtype0:builtins.property`a
+Float32Dtype(pandas.core.arrays.floating.Float32Dtype"'pandas.core.arrays.numeric.NumericDtypea
+Float64Dtype(pandas.core.arrays.floating.Float64Dtype"'pandas.core.arrays.numeric.NumericDtype5
+Grouper#pandas.core.groupby.grouper.Grouper"builtins.object*
+__repr__,pandas.core.groupby.grouper.Grouper.__repr__"
+builtins.str"builtins.str*LJ
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper0:typing.finalP2
+__new__+pandas.core.groupby.grouper.Grouper.__new__
+__new__+pandas.core.groupby.grouper.Grouper.__new__"
+(pandas.core.groupby.grouper.Grouper.SelfJ
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper(*
+cls
+.Type[pandas.core.groupby.grouper.Grouper.Self]
+(pandas.core.groupby.grouper.Grouper.SelfJ
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper("type*l
+keya
+Union[TypeAlias[Any],None]7
+TypeAlias[Any]
+Any"pandas._typing.KeysArgType
+None *
+level
+Union[TypeAlias[Union[typing.Hashable,builtins.int]],TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]]
+Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]
+0typing.MutableSequence[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.MutableSequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
+builtins.range"builtins.range"pandas._typing.ListLikeHashable
+None *	
+axis	
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault **
+sort
+
builtins.bool"
builtins.bool *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+__new__+pandas.core.groupby.grouper.Grouper.__new__"D
+ pandas.core.resample.TimeGrouper" pandas.core.resample.TimeGrouper*
+cls
+)Type[pandas.core.groupby.grouper.Grouper]J
+#pandas.core.groupby.grouper.Grouper"#pandas.core.groupby.grouper.Grouper"type*
+args
+Any*
+freq
+ETypeAlias[Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]]
+:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.strP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas._typing.Frequency*
+kwargs
+Any0:typing.overloadXr
+key'pandas.core.groupby.grouper.Grouper.keya
+Union[TypeAlias[Any],None]7
+TypeAlias[Any]
+Any"pandas._typing.KeysArgType
+Noner	
+level)pandas.core.groupby.grouper.Grouper.level
+Union[TypeAlias[Union[typing.Hashable,builtins.int]],TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]]
+Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]
+0typing.MutableSequence[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.MutableSequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
+builtins.range"builtins.range"pandas._typing.ListLikeHashable
+Noner
+freq(pandas.core.groupby.grouper.Grouper.freq
+QUnion[TypeAlias[Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]],None]
+ETypeAlias[Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]]
+:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.strP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas._typing.Frequency
+Noner
+axis(pandas.core.groupby.grouper.Grouper.axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.AxisrP
+sort(pandas.core.groupby.grouper.Grouper.sort
+
builtins.bool"
builtins.boolrT
+dropna*pandas.core.groupby.grouper.Grouper.dropna
+
builtins.bool"
builtins.boolrl
+binner*pandas.core.groupby.grouper.Grouper.binner6
+TypeAlias[Any]
+Any"pandas._typing.Incomplete
+Indexpandas.core.indexes.base.Index"pandas.core.base.IndexOpsMixin*/
+str"pandas.core.indexes.base.Index.str"
+pandas.core.strings.StringMethods[pandas.core.indexes.base.Index.Self,pandas.core.indexes.multi.MultiIndex,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(L
+$pandas.core.indexes.multi.MultiIndex"$pandas.core.indexes.multi.MultiIndex
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool"!pandas.core.strings.StringMethods*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(0:builtins.property`*
+is_"pandas.core.indexes.base.Index.is_"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+other
+Any*
+__len__&pandas.core.indexes.base.Index.__len__"
+builtins.int"builtins.int*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+	__array__(pandas.core.indexes.base.Index.__array__"9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+dtype
+Any *d
+__array_wrap__-pandas.core.indexes.base.Index.__array_wrap__*
+self*
+
+result*
+context *
+dtype$pandas.core.indexes.base.Index.dtype"
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
+ravel$pandas.core.indexes.base.Index.ravel"
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*)
+order
+builtins.str"builtins.str *@
+view#pandas.core.indexes.base.Index.view*
+self*	
+cls *"
+astype%pandas.core.indexes.base.Index.astype"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+dtype
+TypeAlias[Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]]
+Union[TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[Any,Unknown]]	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype8
+typing.Mapping[Any,Unknown]
+Any"typing.Mapping"pandas._typing.DtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+take#pandas.core.indexes.base.Index.take"
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+indices
+Any*(
+axis
+builtins.int"builtins.int *0
+
+allow_fill
+
builtins.bool"
builtins.bool *
+
+fill_value
+Any *
+kwargs
+Any*R
+repeat%pandas.core.indexes.base.Index.repeat*
+self*
+repeats*
+
+axis *(
+copy#pandas.core.indexes.base.Index.copy"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+name
+Any **
+deep
+
builtins.bool"
builtins.bool *I
+__copy__'pandas.core.indexes.base.Index.__copy__*
+self*
+
+kwargs*Q
+__deepcopy__+pandas.core.indexes.base.Index.__deepcopy__*
+self*
+
+memo *
+format%pandas.core.indexes.base.Index.format"J
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index**
+name
+
builtins.bool"
builtins.bool *
+	formatter
++Union[CallableType[builtins.function],None]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None **
+na_rep
+builtins.str"builtins.str *G
+
to_flat_index,pandas.core.indexes.base.Index.to_flat_index*
+self*
+	to_series(pandas.core.indexes.base.Index.to_series"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+index
+Any *
+name
+Any *
+to_frame'pandas.core.indexes.base.Index.to_frame":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*+
+index
+
builtins.bool"
builtins.bool *
+name
+Any *
+	set_names(pandas.core.indexes.base.Index.set_names"
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+names
+Any*
+level
+Any *-
+inplace
+
builtins.bool"
builtins.bool *
+nlevels&pandas.core.indexes.base.Index.nlevels"
+builtins.int"builtins.int*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
+	sortlevel(pandas.core.indexes.base.Index.sortlevel"
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+level
+Any */
+	ascending
+
builtins.bool"
builtins.bool *
+sort_remaining
+Any *
+get_level_values/pandas.core.indexes.base.Index.get_level_values"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
 builtins.float"builtins.float$
 builtins.complex"builtins.complex	
 TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
@@ -12479,24 +17409,639 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*k
+level`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str*
+	droplevel(pandas.core.indexes.base.Index.droplevel"
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-name
-Any*-
-inplace
-
builtins.bool"
builtins.bool *
-nlevels&pandas.core.indexes.base.Index.nlevels"
-builtins.int"builtins.int*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+level
+LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level)
+builtins.list[Unknown]"
builtins.list *
+is_monotonic_increasing6pandas.core.indexes.base.Index.is_monotonic_increasing"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
+is_monotonic_decreasing6pandas.core.indexes.base.Index.is_monotonic_decreasing"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
+	is_unique(pandas.core.indexes.base.Index.is_unique"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
+has_duplicates-pandas.core.indexes.base.Index.has_duplicates"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
+
+is_boolean)pandas.core.indexes.base.Index.is_boolean"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+
+is_integer)pandas.core.indexes.base.Index.is_integer"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+is_floating*pandas.core.indexes.base.Index.is_floating"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+
+is_numeric)pandas.core.indexes.base.Index.is_numeric"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+	is_object(pandas.core.indexes.base.Index.is_object"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+is_categorical-pandas.core.indexes.base.Index.is_categorical"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+is_interval*pandas.core.indexes.base.Index.is_interval"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*G
+
holds_integer,pandas.core.indexes.base.Index.holds_integer*
+self*
+
inferred_type,pandas.core.indexes.base.Index.inferred_type"
+builtins.str"builtins.str*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*A
+
+__reduce__)pandas.core.indexes.base.Index.__reduce__*
+self*
+hasnans&pandas.core.indexes.base.Index.hasnans"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*5
+isna#pandas.core.indexes.base.Index.isna*
+self*7
+notna$pandas.core.indexes.base.Index.notna*
+self*V
+fillna%pandas.core.indexes.base.Index.fillna*
+self*
+value *
+downcast *)
+dropna%pandas.core.indexes.base.Index.dropna"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+how
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *(
+unique%pandas.core.indexes.base.Index.unique"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12523,20 +18068,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
-	sortlevel(pandas.core.indexes.base.Index.sortlevel"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12563,27 +18104,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
 level
-Any */
-	ascending
-
builtins.bool"
builtins.bool *
-sort_remaining
-Any *
-get_level_values/pandas.core.indexes.base.Index.get_level_values"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any *+
+drop_duplicates.pandas.core.indexes.base.Index.drop_duplicates"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12610,24 +18142,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*k
-level`
- Union[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str*
-	droplevel(pandas.core.indexes.base.Index.droplevel"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12654,27 +18178,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-level
-LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level)
-builtins.list[Unknown]"
builtins.list *
-is_monotonic_increasing6pandas.core.indexes.base.Index.is_monotonic_increasing"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+keep
+[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.bool]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.NaPosition:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+
+duplicated)pandas.core.indexes.base.Index.duplicated"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12701,20 +18232,25 @@ LUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[Unknown]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
-is_monotonic_decreasing6pandas.core.indexes.base.Index.is_monotonic_decreasing"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+keep
+IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+__and__&pandas.core.indexes.base.Index.__and__"
+NoReturn
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12741,20 +18277,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
-	is_unique(pandas.core.indexes.base.Index.is_unique"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+NoReturn
+*
+__rand__'pandas.core.indexes.base.Index.__rand__"
+NoReturn
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12781,20 +18316,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
-has_duplicates-pandas.core.indexes.base.Index.has_duplicates"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+NoReturn
+*
+__or__%pandas.core.indexes.base.Index.__or__"
+NoReturn
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12821,21 +18355,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*
-
-is_boolean)pandas.core.indexes.base.Index.is_boolean"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+NoReturn
+*
+__ror__&pandas.core.indexes.base.Index.__ror__"
+NoReturn
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12862,21 +18394,19 @@ is_boolean)pandas.core.indexes.base.Index.is_boolean"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-
-is_integer)pandas.core.indexes.base.Index.is_integer"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+NoReturn
+*
+__xor__&pandas.core.indexes.base.Index.__xor__"
+NoReturn
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12903,20 +18433,19 @@ is_integer)pandas.core.indexes.base.Index.is_integer"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-is_floating*pandas.core.indexes.base.Index.is_floating"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+NoReturn
+*
+__rxor__'pandas.core.indexes.base.Index.__rxor__"
+NoReturn
+*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12943,21 +18472,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-
-is_numeric)pandas.core.indexes.base.Index.is_numeric"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+NoReturn
+*(
+__neg__&pandas.core.indexes.base.Index.__neg__"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -12984,20 +18510,15 @@ is_numeric)pandas.core.indexes.base.Index.is_numeric"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-	is_object(pandas.core.indexes.base.Index.is_object"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13024,20 +18545,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-is_categorical-pandas.core.indexes.base.Index.is_categorical"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+__nonzero__*pandas.core.indexes.base.Index.__nonzero__"
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13064,20 +18582,63 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+union$pandas.core.indexes.base.Index.union"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-is_interval*pandas.core.indexes.base.Index.is_interval"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+other
+RUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any]]
+'builtins.list[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+sort
+Any *P
+intersection+pandas.core.indexes.base.Index.intersection"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13104,20 +18665,52 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-is_mixed'pandas.core.indexes.base.Index.is_mixed"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*'
+other'
+KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13144,27 +18737,54 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*G
-
holds_integer,pandas.core.indexes.base.Index.holds_integer*
-self*^
-
inferred_type,pandas.core.indexes.base.Index.inferred_type*
-self0:builtins.property`*A
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(**
+sort
+
builtins.bool"
builtins.bool **
 
-__reduce__)pandas.core.indexes.base.Index.__reduce__*
-self*
-hasnans&pandas.core.indexes.base.Index.hasnans"
-
builtins.bool"
builtins.bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+difference)pandas.core.indexes.base.Index.difference"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13191,27 +18811,16 @@ __reduce__)pandas.core.indexes.base.Index.__reduce__*
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index0:builtins.property`*5
-isna#pandas.core.indexes.base.Index.isna*
-self*7
-notna$pandas.core.indexes.base.Index.notna*
-self*V
-fillna%pandas.core.indexes.base.Index.fillna*
-self*
-value *
-downcast *0
-dropna%pandas.core.indexes.base.Index.dropna"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13238,19 +18847,26 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+other
+=Union[builtins.list[Any],pandas.core.indexes.base.Index[Any]],
+builtins.list[Any]
+Any"
builtins.listN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*S
+sortG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *P
+symmetric_difference3pandas.core.indexes.base.Index.symmetric_difference"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13277,25 +18893,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-how
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str */
-unique%pandas.core.indexes.base.Index.unique"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13322,19 +18929,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*'
+other'
+KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13361,21 +18965,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-level
-Any *3
-drop_duplicates.pandas.core.indexes.base.Index.drop_duplicates"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13402,19 +19000,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+result_name
+Any *
+sort
+Any * 
+get_loc&pandas.core.indexes.base.Index.get_loc"
+Union[builtins.int,builtins.slice,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]]
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.slice"builtins.slice
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13441,37 +19050,54 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-keep
-[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.bool]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+key
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label*
+method
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FillnaOptions7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+	tolerance
+Any *{
+get_indexer*pandas.core.indexes.base.Index.get_indexer*
+self*
 
-duplicated)pandas.core.indexes.base.Index.duplicated"
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+target*
+method *
+limit *
+	tolerance *
+reindex&pandas.core.indexes.base.Index.reindex*
+self*
+
+target*
+method *
+level *
+limit *
+	tolerance *
+join#pandas.core.indexes.base.Index.join"
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13498,28 +19124,29 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-keep
-IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-__and__&pandas.core.indexes.base.Index.__and__"
-NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+other
+Any*'
+how
+builtins.str"builtins.str *
+level
+Any *5
+return_indexers
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *
+values%pandas.core.indexes.base.Index.values"9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13546,22 +19173,17 @@ IUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.bool]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-NoReturn
-*
-__rand__'pandas.core.indexes.base.Index.__rand__"
-NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
+array$pandas.core.indexes.base.Index.array"P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13588,22 +19210,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-NoReturn
-*
-__or__%pandas.core.indexes.base.Index.__or__"
-NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
+memory_usage+pandas.core.indexes.base.Index.memory_usage"
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13630,22 +19247,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-NoReturn
-*
-__ror__&pandas.core.indexes.base.Index.__ror__"
-NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index**
+deep
+
builtins.bool"
builtins.bool *N
+where$pandas.core.indexes.base.Index.where*
+self*
+cond*
+other *
+__contains__+pandas.core.indexes.base.Index.__contains__"
+
builtins.bool"
builtins.bool*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13672,22 +19289,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-NoReturn
-*
-__xor__&pandas.core.indexes.base.Index.__xor__"
-NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*	
+Any*
+__setitem__*pandas.core.indexes.base.Index.__setitem__"
+None*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13714,22 +19326,26 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-NoReturn
-*
-__rxor__'pandas.core.indexes.base.Index.__rxor__"
-NoReturn
-*
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*	
+Any*	
+Any*D
+append%pandas.core.indexes.base.Index.append*
+self*	
+other*P
+putmask&pandas.core.indexes.base.Index.putmask*
+self*
+mask*	
+value*
+equals%pandas.core.indexes.base.Index.equals"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13756,21 +19372,19 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-NoReturn
-*/
-__neg__&pandas.core.indexes.base.Index.__neg__"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+other
+Any*
+	identical(pandas.core.indexes.base.Index.identical"
+
builtins.bool"
builtins.bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13797,18 +19411,26 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+other
+Any*@
+asof#pandas.core.indexes.base.Index.asof*
+self*	
+label*T
+	asof_locs(pandas.core.indexes.base.Index.asof_locs*
+self*	
+where*
+mask*
+sort_values*pandas.core.indexes.base.Index.sort_values"
+Any*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13835,20 +19457,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-__nonzero__*pandas.core.indexes.base.Index.__nonzero__"
-None*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*4
+return_indexer
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *
+sort#pandas.core.indexes.base.Index.sort"
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13875,21 +19498,21 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-union$pandas.core.indexes.base.Index.union"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+args
+Any*
+kwargs
+Any*
+shift$pandas.core.indexes.base.Index.shift"
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13916,28 +19539,40 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-other
-RUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[Any]]
-'builtins.list[pandas._typing.HashableT]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-sort
-Any *^
-intersection+pandas.core.indexes.base.Index.intersection"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*+
+periods
+builtins.int"builtins.int *
+freq
+Any *Q
+argsort&pandas.core.indexes.base.Index.argsort*
+self*
+args*
+
+kwargs*e
+get_indexer_non_unique5pandas.core.indexes.base.Index.get_indexer_non_unique*
+self*
+
+target*c
+get_indexer_for.pandas.core.indexes.base.Index.get_indexer_for*
+self*
+
+target*
+
+kwargs*
+groupby&pandas.core.indexes.base.Index.groupby"
+5builtins.dict[typing.Hashable,numpy.ndarray[Any,Any]]"
+typing.Hashable"typing.Hashable9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -13964,19 +19599,20 @@ RUnion[builtins.list[pandas._typing.HashableT],pandas.core.indexes.base.Index[An
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+values
+Any0:typing.finalP*
+map"pandas.core.indexes.base.Index.map"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14003,19 +19639,27 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*.
-other.
-KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+mapper
+Any*
+	na_action
+Any *
+isin#pandas.core.indexes.base.Index.isin"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14042,18 +19686,44 @@ KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+values
+Any*
+level
+Any *k
+
slice_indexer,pandas.core.indexes.base.Index.slice_indexer*
+self*
+start *	
+end *
+
+step *`
+get_slice_bound.pandas.core.indexes.base.Index.get_slice_bound*
+self*	
+label*
+side*e
+
+slice_locs)pandas.core.indexes.base.Index.slice_locs*
+self*
+start *	
+end *
+
+step *B
+delete%pandas.core.indexes.base.Index.delete*
+self*
+loc*L
+insert%pandas.core.indexes.base.Index.insert*
+self*
+loc*
+item*(
+drop#pandas.core.indexes.base.Index.drop"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14080,22 +19750,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(**
-sort
-
builtins.bool"
builtins.bool *1
-
-difference)pandas.core.indexes.base.Index.difference"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14122,19 +19786,22 @@ difference)pandas.core.indexes.base.Index.difference"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+labels
+Any**
+errors
+builtins.str"builtins.str *
+shape$pandas.core.indexes.base.Index.shape"L
+builtins.tuple[builtins.int]
+builtins.int"builtins.int"builtins.tuple*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14161,29 +19828,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-other
-=Union[builtins.list[Any],pandas.core.indexes.base.Index[Any]],
-builtins.list[Any]
-Any"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*S
-sortG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *_
-symmetric_difference3pandas.core.indexes.base.Index.symmetric_difference"
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index0:builtins.property`*
+__eq__%pandas.core.indexes.base.Index.__eq__"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14210,19 +19870,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-self
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*$"
+builtins.object"builtins.object*&
+__iter__'pandas.core.indexes.base.Index.__iter__"
+"typing.Iterator[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14249,19 +19906,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*.
-other.
-KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterator*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14288,18 +19940,22 @@ KUnion[builtins.list[pandas._typing.S1],pandas.core.indexes.base.Index.Self]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-#pandas.core.indexes.base.Index.Self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*
+__ne__%pandas.core.indexes.base.Index.__ne__"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14326,24 +19982,24 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
-result_name
-Any *
-sort
-Any *
-get_loc&pandas.core.indexes.base.Index.get_loc"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index*$"
+builtins.object"builtins.object*?
+__le__%pandas.core.indexes.base.Index.__le__"
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_bool*
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -14370,57 +20026,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index*
-key
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label*
-method
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None *
-	tolerance
-Any *{
-get_indexer*pandas.core.indexes.base.Index.get_indexer*
-self*
-
-target*
-method *
-limit *
-	tolerance *
-reindex&pandas.core.indexes.base.Index.reindex*
-self*
-
-target*
-method *
-level *
-limit *
-	tolerance *
-join#pandas.core.indexes.base.Index.join"
-Any*
-self
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*''
+
+rename%pandas.core.indexes.base.Index.rename)
+rename%pandas.core.indexes.base.Index.rename"
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16797,37 +22528,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"type*
-data
-{Union[typing.Sequence[pandas._libs.tslibs.period.Period],pandas.core.base.IndexOpsMixin[pandas._libs.tslibs.period.Period]]
-2typing.Sequence[pandas._libs.tslibs.period.Period]F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period"typing.Sequence
-Apandas.core.base.IndexOpsMixin[pandas._libs.tslibs.period.Period]F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period"pandas.core.base.IndexOpsMixin*[
-dtypeN
-%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype **
-copy
-
builtins.bool"
builtins.bool *
-name
-Any *3
-
tupleize_cols
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadX
-__new__&pandas.core.indexes.base.Index.__new__"P
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-cls
-7Type[pandas.core.indexes.base.Index[pandas._typing.S1]]
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+self
+#pandas.core.indexes.base.Index.Self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16854,34 +22564,22 @@ Apandas.core.base.IndexOpsMixin[pandas._libs.tslibs.period.Period]F
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"type*:
-data0
-typing.Iterable[Any]
-Any"typing.Iterable*Y
-dtypeN
-%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype**
-copy
-
builtins.bool"
builtins.bool *
-name
-Any *3
-
tupleize_cols
-
builtins.bool"
builtins.bool *
-kwargs
-Any0:typing.overloadXB
-__new__&pandas.core.indexes.base.Index.__new__"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-cls
-7Type[pandas.core.indexes.base.Index[pandas._typing.S1]]
-1pandas.core.indexes.base.Index[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.indexes.base.Index"pandas.core.indexes.base.Index(*
+name
+Any*I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadX
+rename%pandas.core.indexes.base.Index.rename"
+None*
+self
+1pandas.core.indexes.base.Index[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -16908,132 +22606,22 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.indexes.base.Index"type*
-data
-vUnion[typing.Sequence[Union[numpy.timedelta64,datetime.timedelta]],pandas.core.base.IndexOpsMixin[datetime.timedelta]]
-TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_self
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar**
+column
+builtins.str"builtins.str *
+aggfunc
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar *
+
+__new__,pandas.core.groupby.generic.NamedAgg.__new__"
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_cls
+.Type[pandas.core.groupby.generic.NamedAgg._NT]
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar"type*(
+column
+builtins.str"builtins.str*
+aggfunc
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_asdict,pandas.core.groupby.generic.NamedAgg._asdict"W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict*
+_self
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_make*pandas.core.groupby.generic.NamedAgg._make"
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
+_cls
+.Type[pandas.core.groupby.generic.NamedAgg._NT]
+(pandas.core.groupby.generic.NamedAgg._NT
+RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
+builtins.str"builtins.str
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar"type*>
+iterable0
+typing.Iterable[Any]
+Any"typing.Iterable*
+new
+Any *
+len
+Any 0:prS
+column+pandas.core.groupby.generic.NamedAgg.column
+builtins.str"builtins.strr
+aggfunc,pandas.core.groupby.generic.NamedAgg.aggfunc
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalarrS
+column+pandas.core.groupby.generic.NamedAgg.column
+builtins.str"builtins.strr
+aggfunc,pandas.core.groupby.generic.NamedAgg.aggfunc
+>TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
+3Union[builtins.str,CallableType[builtins.function]]
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalarr
+_fields,pandas.core.groupby.generic.NamedAgg._fields`
+ Tuple[builtins.str,builtins.str]
+builtins.str"builtins.str
+builtins.str"builtins.strr
+_field_types1pandas.core.groupby.generic.NamedAgg._field_typesW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dictr
+_field_defaults4pandas.core.groupby.generic.NamedAgg._field_defaultsW
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dictrU
+_source,pandas.core.groupby.generic.NamedAgg._source
+builtins.str"builtins.strr
+__annotations__4pandas.core.groupby.generic.NamedAgg.__annotations__W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+Period!pandas._libs.tslibs.period.Period"&pandas._libs.tslibs.period.PeriodMixin*
+__init__*pandas._libs.tslibs.period.Period.__init__"
+None*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
+value
+Union[pandas._libs.tslibs.period.Period,builtins.str,datetime.datetime,datetime.date,pandas._libs.tslibs.timestamps.Timestamp,None]F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
+builtins.str"builtins.str&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.dateT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp
+None *
+freq
+?Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset,None]
+builtins.str"builtins.strP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+None *S
+ordinalD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *P
+yearD
+Union[builtins.int,None]
+builtins.int"builtins.int
 None *Q
-limitD
+monthD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None *
-	tolerance
-Any *
-get_indexer_non_uniqueApandas.core.indexes.interval.IntervalIndex.get_indexer_non_unique"*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*Z
-targetN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-left/pandas.core.indexes.interval.IntervalIndex.left"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-right0pandas.core.indexes.interval.IntervalIndex.right"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-mid.pandas.core.indexes.interval.IntervalIndex.mid"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-length1pandas.core.indexes.interval.IntervalIndex.length"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`*
-	get_value4pandas.core.indexes.interval.IntervalIndex.get_value"
-Any*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-series
-/TypeAlias[Type[pandas.core.series.Series[Any]]]t
-$Type[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"type"$pandas.core.dtypes.generic.ABCSeries*
-key
-Any*
-is_all_dates7pandas.core.indexes.interval.IntervalIndex.is_all_dates"
-
builtins.bool"
builtins.bool*
-self
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex0:builtins.property`2Z
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
-Xpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.int]]l
-,pandas._libs.interval.Interval[builtins.int]
-builtins.int"builtins.int"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-breaks	
-TypeAlias[Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]]
-Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]N
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Seriesl
-,pandas.core.indexes.base.Index[builtins.int]
-builtins.int"builtins.int"pandas.core.indexes.base.Index"&pandas.core.indexes.interval._EdgesInt*
-closed
+None *S
+quarterD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *O
+dayD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *P
+hourD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *R
+minuteD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *R
+secondD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+day%pandas._libs.tslibs.period.Period.day"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+	dayofweek+pandas._libs.tslibs.period.Period.dayofweek"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+	dayofyear+pandas._libs.tslibs.period.Period.dayofyear"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+daysinmonth-pandas._libs.tslibs.period.Period.daysinmonth"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+
days_in_month/pandas._libs.tslibs.period.Period.days_in_month"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+end_time*pandas._libs.tslibs.period.Period.end_time"T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+freq&pandas._libs.tslibs.period.Period.freq"P
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+freqstr)pandas._libs.tslibs.period.Period.freqstr"
+builtins.str"builtins.str*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+hour&pandas._libs.tslibs.period.Period.hour"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+minute(pandas._libs.tslibs.period.Period.minute"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+month'pandas._libs.tslibs.period.Period.month"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+quarter)pandas._libs.tslibs.period.Period.quarter"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+qyear'pandas._libs.tslibs.period.Period.qyear"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+second(pandas._libs.tslibs.period.Period.second"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+ordinal)pandas._libs.tslibs.period.Period.ordinal"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+is_leap_year.pandas._libs.tslibs.period.Period.is_leap_year"
+
builtins.bool"
builtins.bool*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+
+start_time,pandas._libs.tslibs.period.Period.start_time"T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+week&pandas._libs.tslibs.period.Period.week"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+weekday)pandas._libs.tslibs.period.Period.weekday"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+
+weekofyear,pandas._libs.tslibs.period.Period.weekofyear"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+year&pandas._libs.tslibs.period.Period.year"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+day_of_year-pandas._libs.tslibs.period.Period.day_of_year"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+day_of_week-pandas._libs.tslibs.period.Period.day_of_week"
+builtins.int"builtins.int*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
+asfreq(pandas._libs.tslibs.period.Period.asfreq"F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
+freq
+:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.strP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+how
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
 ^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
@@ -19212,41 +25484,34 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
-Zpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.float]]r
-.pandas._libs.interval.Interval[builtins.float] 
-builtins.float"builtins.float"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-breaks	
-TypeAlias[Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]]
-Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]T
-typing.Sequence[builtins.float] 
-builtins.float"builtins.float"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayh
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Seriesr
-.pandas.core.indexes.base.Index[builtins.float] 
-builtins.float"builtins.float"pandas.core.indexes.base.Index"(pandas.core.indexes.interval._EdgesFloat*
-closed
+builtins.str"builtins.str")pandas._libs.tslibs.period._PeriodFreqHow *
+now%pandas._libs.tslibs.period.Period.now"F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
+clsy
+'Type[pandas._libs.tslibs.period.Period]F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period"type*
+freq
+:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.strP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset 0:builtins.classmethodp*
+strftime*pandas._libs.tslibs.period.Period.strftime"
+builtins.str"builtins.str*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*%
+fmt
+builtins.str"builtins.str*
+to_timestamp.pandas._libs.tslibs.period.Period.to_timestamp"T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*P
+selfF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
+freq
+?Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset,None]
+builtins.str"builtins.strP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+None *
+how
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]	
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
 ^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
@@ -19256,46 +25521,7 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
-tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]]
-Hpandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
-breaks
-TypeAlias[Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]]
-
-Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]
-ntyping.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]]
-]TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]
-RUnion[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]&
-datetime.datetime"datetime.datetime$
-numpy.datetime64"numpy.datetime64T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._typing.DatetimeLike"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeriesZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex",pandas.core.indexes.interval._EdgesTimestamp*
-closed
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str")pandas._libs.tslibs.period._PeriodFreqHow7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -19303,41 +25529,7 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp
-from_breaks6pandas.core.indexes.interval.IntervalIndex.from_breaks"
-tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]]
-Hpandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-breaks	
-TypeAlias[Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]]
-Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]
-9typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"typing.Sequence
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex",pandas.core.indexes.interval._EdgesTimedelta*
-closed
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -19345,848 +25537,2477 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp2
-from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays
-from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays"
-Xpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.int]]l
-,pandas._libs.interval.Interval[builtins.int]
-builtins.int"builtins.int"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-left	
-TypeAlias[Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]]
-Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]N
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
+builtins.str"builtins.str"0pandas._libs.tslibs.period._PeriodToTimestampHow 2
+__sub__)pandas._libs.tslibs.period.Period.__sub__
+__sub__)pandas._libs.tslibs.period.Period.__sub__"F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
+TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]]
+Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
+datetime.timedelta"datetime.timedelta&
+numpy.timedelta64"numpy.timedelta64
+4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
+)numpy.signedinteger[numpy._typing._64Bit],
+numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64
+builtins.int"builtins.intP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"(pandas._libs.tslibs.period._PeriodAddSub0:typing.overloadX
+__sub__)pandas._libs.tslibs.period.Period.__sub__"P
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+__sub__)pandas._libs.tslibs.period.Period.__sub__"J
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*LJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
+__sub__)pandas._libs.tslibs.period.Period.__sub__"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
+__sub__)pandas._libs.tslibs.period.Period.__sub__"B
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*JH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+__sub__)pandas._libs.tslibs.period.Period.__sub__"P
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX2
+__add__)pandas._libs.tslibs.period.Period.__add__
+__add__)pandas._libs.tslibs.period.Period.__add__"F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
+TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]]
+Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
+datetime.timedelta"datetime.timedelta&
+numpy.timedelta64"numpy.timedelta64
+4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
+)numpy.signedinteger[numpy._typing._64Bit],
+numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64
+builtins.int"builtins.intP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"(pandas._libs.tslibs.period._PeriodAddSub0:typing.overloadX
+__add__)pandas._libs.tslibs.period.Period.__add__"J
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*LJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
+__add__)pandas._libs.tslibs.period.Period.__add__"P
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*PN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index0:typing.overloadX
+__add__)pandas._libs.tslibs.period.Period.__add__"B
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
+IUnion[pandas.core.series.OffsetSeries,pandas.core.series.TimedeltaSeries]B
+pandas.core.series.OffsetSeries"pandas.core.series.OffsetSeriesH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX2
+__eq__(pandas._libs.tslibs.period.Period.__eq__
+__eq__(pandas._libs.tslibs.period.Period.__eq__"
+
builtins.bool"
builtins.bool*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+__eq__(pandas._libs.tslibs.period.Period.__eq__"
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Seriesl
-,pandas.core.indexes.base.Index[builtins.int]
-builtins.int"builtins.int"pandas.core.indexes.base.Index"&pandas.core.indexes.interval._EdgesInt*	
-right	
-TypeAlias[Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]]
-Union[typing.Sequence[builtins.int],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.series.Series[builtins.int],pandas.core.indexes.base.Index[builtins.int]]N
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
+__eq__(pandas._libs.tslibs.period.Period.__eq__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX
+__eq__(pandas._libs.tslibs.period.Period.__eq__":
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*$"
+builtins.object"builtins.object0:typing.overloadX2	
+__ge__(pandas._libs.tslibs.period.Period.__ge__
+__ge__(pandas._libs.tslibs.period.Period.__ge__"
+
builtins.bool"
builtins.bool*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+__ge__(pandas._libs.tslibs.period.Period.__ge__"
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Seriesl
-,pandas.core.indexes.base.Index[builtins.int]
-builtins.int"builtins.int"pandas.core.indexes.base.Index"&pandas.core.indexes.interval._EdgesInt*
-closed
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp
-from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays"
-Zpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[builtins.float]]r
-.pandas._libs.interval.Interval[builtins.float] 
-builtins.float"builtins.float"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-left	
-TypeAlias[Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]]
-Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]T
-typing.Sequence[builtins.float] 
-builtins.float"builtins.float"typing.Sequence
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
+__ge__(pandas._libs.tslibs.period.Period.__ge__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX2	
+__gt__(pandas._libs.tslibs.period.Period.__gt__
+__gt__(pandas._libs.tslibs.period.Period.__gt__"
+
builtins.bool"
builtins.bool*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+__gt__(pandas._libs.tslibs.period.Period.__gt__"
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayh
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Seriesr
-.pandas.core.indexes.base.Index[builtins.float] 
-builtins.float"builtins.float"pandas.core.indexes.base.Index"(pandas.core.indexes.interval._EdgesFloat*	
-right	
-TypeAlias[Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]]
-Union[typing.Sequence[builtins.float],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.Series[builtins.float],pandas.core.indexes.base.Index[builtins.float]]T
-typing.Sequence[builtins.float] 
-builtins.float"builtins.float"typing.Sequence
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
+__gt__(pandas._libs.tslibs.period.Period.__gt__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX2	
+__le__(pandas._libs.tslibs.period.Period.__le__
+__le__(pandas._libs.tslibs.period.Period.__le__"
+
builtins.bool"
builtins.bool*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+__le__(pandas._libs.tslibs.period.Period.__le__"
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayh
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Seriesr
-.pandas.core.indexes.base.Index[builtins.float] 
-builtins.float"builtins.float"pandas.core.indexes.base.Index"(pandas.core.indexes.interval._EdgesFloat*
-closed
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
-copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp'
-from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays"
-tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]]
-Hpandas._libs.interval.Interval[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*
-left
-TypeAlias[Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]]
-
-Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]
-ntyping.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]]
-]TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]
-RUnion[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]&
-datetime.datetime"datetime.datetime$
-numpy.datetime64"numpy.datetime64T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._typing.DatetimeLike"typing.Sequence
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
+__le__(pandas._libs.tslibs.period.Period.__le__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX2	
+__lt__(pandas._libs.tslibs.period.Period.__lt__
+__lt__(pandas._libs.tslibs.period.Period.__lt__"
+
builtins.bool"
builtins.bool*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+__lt__(pandas._libs.tslibs.period.Period.__lt__"
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeriesZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex",pandas.core.indexes.interval._EdgesTimestamp*
-right
-TypeAlias[Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]]
-
-Union[typing.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimestampSeries,pandas.core.indexes.datetimes.DatetimeIndex]
-ntyping.Sequence[TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]]
-]TypeAlias[Union[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]]
-RUnion[datetime.datetime,numpy.datetime64,pandas._libs.tslibs.timestamps.Timestamp]&
-datetime.datetime"datetime.datetime$
-numpy.datetime64"numpy.datetime64T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas._typing.DatetimeLike"typing.Sequence
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
+__lt__(pandas._libs.tslibs.period.Period.__lt__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX2
+__ne__(pandas._libs.tslibs.period.Period.__ne__
+__ne__(pandas._libs.tslibs.period.Period.__ne__"
+
builtins.bool"
builtins.bool*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+__ne__(pandas._libs.tslibs.period.Period.__ne__"
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
 5numpy.dtype[numpy._typing._array_like._ScalarType_co][
 (numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeriesZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex",pandas.core.indexes.interval._EdgesTimestamp*
-closed
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *.
-name"
-typing.Hashable"typing.Hashable **
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
+__ne__(pandas._libs.tslibs.period.Period.__ne__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX
+__ne__(pandas._libs.tslibs.period.Period.__ne__":
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*$"
+builtins.object"builtins.object0:typing.overloadX2
+__radd__*pandas._libs.tslibs.period.Period.__radd__
+__radd__*pandas._libs.tslibs.period.Period.__radd__"F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
+TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]]
+Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
+datetime.timedelta"datetime.timedelta&
+numpy.timedelta64"numpy.timedelta64
+4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
+)numpy.signedinteger[numpy._typing._64Bit],
+numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64
+builtins.int"builtins.intP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"(pandas._libs.tslibs.period._PeriodAddSub0:typing.overloadX
+__radd__*pandas._libs.tslibs.period.Period.__radd__"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*PN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index0:typing.overloadX
+__radd__*pandas._libs.tslibs.period.Period.__radd__"B
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*JH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
+__radd__*pandas._libs.tslibs.period.Period.__radd__"J
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*LJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
+PeriodDtype%pandas.core.dtypes.dtypes.PeriodDtype".pandas.core.dtypes.dtypes.PandasExtensionDtype*
+__init__.pandas.core.dtypes.dtypes.PeriodDtype.__init__"
+None*X
+selfN
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype*
+freq
+wUnion[builtins.str,pandas._libs.tslibs.offsets.SingleConstructorOffset,pandas._libs.tslibs.offsets.RelativeDeltaOffset]
+builtins.str"builtins.strj
+3pandas._libs.tslibs.offsets.SingleConstructorOffset"3pandas._libs.tslibs.offsets.SingleConstructorOffsetb
+/pandas._libs.tslibs.offsets.RelativeDeltaOffset"/pandas._libs.tslibs.offsets.RelativeDeltaOffset *
+freq*pandas.core.dtypes.dtypes.PeriodDtype.freq"P
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*X
+selfN
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype0:builtins.property`*
+na_value.pandas.core.dtypes.dtypes.PeriodDtype.na_value"J
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*X
+selfN
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype0:builtins.property`=
+PeriodIndex&pandas.core.indexes.period.PeriodIndex"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin"1pandas.core.indexes.accessors.PeriodIndexFieldOps*
+__new__.pandas.core.indexes.period.PeriodIndex.__new__"
+Any*
+cls
+,Type[pandas.core.indexes.period.PeriodIndex]P
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"type*
+data
+Any *
+ordinal
+Any *
+freq
+Any *
+tz
+Any *
+dtype
+Any **
 copy
-
builtins.bool"
builtins.bool *
-dtype
-3Union[pandas.core.dtypes.dtypes.IntervalDtype,None]R
-'pandas.core.dtypes.dtypes.IntervalDtype"'pandas.core.dtypes.dtypes.IntervalDtype
-None 0:typing.overload:builtins.classmethodXp 
-from_arrays6pandas.core.indexes.interval.IntervalIndex.from_arrays"
-tpandas.core.indexes.interval.IntervalIndex[pandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]]
-Hpandas._libs.interval.Interval[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex*
-cls
-JType[pandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]]
-Dpandas.core.indexes.interval.IntervalIndex[pandas._typing.IntervalT]
-pandas._typing.IntervalTN
-#pandas._libs.interval.Interval[Any]
-Any"pandas._libs.interval.Interval"pandas._libs.interval.Interval"*pandas.core.indexes.interval.IntervalIndex"type*	
-left	
-TypeAlias[Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]]
-Union[typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex]
-9typing.Sequence[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"typing.Sequence
+
builtins.bool"
builtins.bool *
+name
+Any *
+fields
+Any*X
+values-pandas.core.indexes.period.PeriodIndex.values*
+self0:builtins.property`*
+__contains__3pandas.core.indexes.period.PeriodIndex.__contains__"
+
builtins.bool"
builtins.bool*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*	
+Any*
+	__array__0pandas.core.indexes.period.PeriodIndex.__array__"9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*Z
+selfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
+dtype
+Any *l
+__array_wrap__5pandas.core.indexes.period.PeriodIndex.__array_wrap__*
+self*
+
+result*
+context *\
+	asof_locs0pandas.core.indexes.period.PeriodIndex.asof_locs*
+self*	
+where*
+mask*
+astype-pandas.core.indexes.period.PeriodIndex.astype"
+Any*Z
+selfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
+dtype
+Any**
+copy
+
builtins.bool"
builtins.bool *'
+how
+builtins.str"builtins.str *
+searchsorted3pandas.core.indexes.period.PeriodIndex.searchsorted"
+Any*Z
+selfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
+value
+Any*(
+side
+builtins.str"builtins.str *
+sorter
+Any *
+is_full.pandas.core.indexes.period.PeriodIndex.is_full"
+
builtins.bool"
builtins.bool*Z
+selfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`*
+
inferred_type4pandas.core.indexes.period.PeriodIndex.inferred_type"
+builtins.str"builtins.str*Z
+selfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`*
+get_indexer2pandas.core.indexes.period.PeriodIndex.get_indexer*
+self*
+
+target*
+method *
+limit *
+	tolerance *m
+get_indexer_non_unique=pandas.core.indexes.period.PeriodIndex.get_indexer_non_unique*
+self*
+
+target*T
+insert-pandas.core.indexes.period.PeriodIndex.insert*
+self*
+loc*
+item*
+join+pandas.core.indexes.period.PeriodIndex.join"
+Any*Z
+selfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
+other
+Any*'
+how
+builtins.str"builtins.str *
+level
+Any *5
+return_indexers
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool *`
+
+difference1pandas.core.indexes.period.PeriodIndex.difference*
+self*	
+other*
+
+sort *
+memory_usage3pandas.core.indexes.period.PeriodIndex.memory_usage"
+Any*Z
+selfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex**
+deep
+
builtins.bool"
builtins.bool *
+freqstr.pandas.core.indexes.period.PeriodIndex.freqstr"
+builtins.str"builtins.str*Z
+selfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`2
+__sub__.pandas.core.indexes.period.PeriodIndex.__sub__
+__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
++pandas.core.indexes.period.PeriodIndex.SelfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
++pandas.core.indexes.period.PeriodIndex.SelfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(0:typing.overloadX
+
+__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"
++pandas.core.indexes.period.PeriodIndex.SelfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
++pandas.core.indexes.period.PeriodIndex.SelfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
+TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]]
+Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
+datetime.timedelta"datetime.timedelta&
+numpy.timedelta64"numpy.timedelta64
+4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
+)numpy.signedinteger[numpy._typing._64Bit],
+numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64
+builtins.int"builtins.intP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"(pandas._libs.tslibs.period._PeriodAddSub0:typing.overloadX
+__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"J
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*LJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
+__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"
++pandas.core.indexes.period.PeriodIndex.SelfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
++pandas.core.indexes.period.PeriodIndex.SelfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
+]Union[pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.timedeltas.Timedelta]^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta0:typing.overloadX2	
+__rsub__/pandas.core.indexes.period.PeriodIndex.__rsub__
+__rsub__/pandas.core.indexes.period.PeriodIndex.__rsub__"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*HF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
+__rsub__/pandas.core.indexes.period.PeriodIndex.__rsub__"N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index*
++pandas.core.indexes.period.PeriodIndex.SelfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
++pandas.core.indexes.period.PeriodIndex.SelfP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(0:typing.overloadX
+__rsub__/pandas.core.indexes.period.PeriodIndex.__rsub__"J
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*RP
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*LJ
+#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadXC
+
+RangeIndex$pandas.core.indexes.range.RangeIndex"pandas.core.indexes.base.Index*
+__new__,pandas.core.indexes.range.RangeIndex.__new__"
+Any*
+cls
+*Type[pandas.core.indexes.range.RangeIndex]L
+$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex"type*
+start
+GUnion[builtins.int,pandas.core.indexes.range.RangeIndex,builtins.range]
+builtins.int"builtins.intL
+$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex 
+builtins.range"builtins.range *(
+stop
+builtins.int"builtins.int *(
+step
+builtins.int"builtins.int *
+dtype
+Any **
+copy
+
builtins.bool"
builtins.bool *
+name
+Any *
+
+from_range/pandas.core.indexes.range.RangeIndex.from_range*
+cls*
+data*
+
+name *
+dtype 0:builtins.classmethodp*G
+
+__reduce__/pandas.core.indexes.range.RangeIndex.__reduce__*
+self*=
+start*pandas.core.indexes.range.RangeIndex.start*
+self*;
+stop)pandas.core.indexes.range.RangeIndex.stop*
+self*;
+step)pandas.core.indexes.range.RangeIndex.step*
+self*
+nbytes+pandas.core.indexes.range.RangeIndex.nbytes"
+builtins.int"builtins.int*V
+selfL
+$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex0:builtins.property`*
+memory_usage1pandas.core.indexes.range.RangeIndex.memory_usage"
+builtins.int"builtins.int*V
+selfL
+$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex**
+deep
+
builtins.bool"
builtins.bool *
+dtype*pandas.core.indexes.range.RangeIndex.dtype"(
+numpy.dtype[Any]
+Any"numpy.dtype*V
+selfL
+$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex0:builtins.property`*
+	is_unique.pandas.core.indexes.range.RangeIndex.is_unique"
+
builtins.bool"
builtins.bool*V
+selfL
+$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex0:builtins.property`*
+is_monotonic_increasingTypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
-_self
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar**
-column
-builtins.str"builtins.str *
-aggfunc
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar *
-
-__new__,pandas.core.groupby.generic.NamedAgg.__new__"
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
-_cls
-.Type[pandas.core.groupby.generic.NamedAgg._NT]
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar"type**
-column
-builtins.str"builtins.str *
-aggfunc
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar *
-_asdict,pandas.core.groupby.generic.NamedAgg._asdict"W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict*
-_self
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
-_make*pandas.core.groupby.generic.NamedAgg._make"
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar*
-_cls
-.Type[pandas.core.groupby.generic.NamedAgg._NT]
-(pandas.core.groupby.generic.NamedAgg._NT
-RTuple[builtins.str,TypeAlias[Union[builtins.str,CallableType[builtins.function]]]]
-builtins.str"builtins.str
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalar"type*>
-iterable0
-typing.Iterable[Any]
-Any"typing.Iterable*
-new
-Any *
-len
-Any 0:prS
-column+pandas.core.groupby.generic.NamedAgg.column
-builtins.str"builtins.strr
-aggfunc,pandas.core.groupby.generic.NamedAgg.aggfunc
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalarrS
-column+pandas.core.groupby.generic.NamedAgg.column
-builtins.str"builtins.strr
-aggfunc,pandas.core.groupby.generic.NamedAgg.aggfunc
->TypeAlias[Union[builtins.str,CallableType[builtins.function]]]
-3Union[builtins.str,CallableType[builtins.function]]
-builtins.str"builtins.strK
-CallableType[builtins.function]&
-builtins.function"builtins.function"%pandas.core.groupby.generic.AggScalarr
-_fields,pandas.core.groupby.generic.NamedAgg._fields`
- Tuple[builtins.str,builtins.str]
-builtins.str"builtins.str
-builtins.str"builtins.strr
-_field_types1pandas.core.groupby.generic.NamedAgg._field_typesW
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dictr
-_field_defaults4pandas.core.groupby.generic.NamedAgg._field_defaultsW
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dictrU
-_source,pandas.core.groupby.generic.NamedAgg._source
-builtins.str"builtins.strr
-__annotations__4pandas.core.groupby.generic.NamedAgg.__annotations__W
-builtins.dict[builtins.str,Any]
-builtins.str"builtins.str
-Any"
builtins.dict
-Period!pandas._libs.tslibs.period.Period"&pandas._libs.tslibs.period.PeriodMixin*
-__init__*pandas._libs.tslibs.period.Period.__init__"
-None*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
-value
-Union[pandas._libs.tslibs.period.Period,builtins.str,datetime.datetime,datetime.date,pandas._libs.tslibs.timestamps.Timestamp,None]F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-builtins.str"builtins.str&
-datetime.datetime"datetime.datetime
-
datetime.date"
datetime.dateT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp
-None *
-freq
-?Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset,None]
-builtins.str"builtins.strP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
-None *S
-ordinalD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *P
-yearD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *Q
-monthD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *S
-quarterD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *O
-dayD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *P
-hourD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *R
-minuteD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *R
-secondD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-day%pandas._libs.tslibs.period.Period.day"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-	dayofweek+pandas._libs.tslibs.period.Period.dayofweek"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-	dayofyear+pandas._libs.tslibs.period.Period.dayofyear"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-daysinmonth-pandas._libs.tslibs.period.Period.daysinmonth"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-
days_in_month/pandas._libs.tslibs.period.Period.days_in_month"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-end_time*pandas._libs.tslibs.period.Period.end_time"T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-freq&pandas._libs.tslibs.period.Period.freq"P
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-freqstr)pandas._libs.tslibs.period.Period.freqstr"
-builtins.str"builtins.str*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-hour&pandas._libs.tslibs.period.Period.hour"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-minute(pandas._libs.tslibs.period.Period.minute"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-month'pandas._libs.tslibs.period.Period.month"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-quarter)pandas._libs.tslibs.period.Period.quarter"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-qyear'pandas._libs.tslibs.period.Period.qyear"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-second(pandas._libs.tslibs.period.Period.second"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-ordinal)pandas._libs.tslibs.period.Period.ordinal"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-is_leap_year.pandas._libs.tslibs.period.Period.is_leap_year"
-
builtins.bool"
builtins.bool*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-
-start_time,pandas._libs.tslibs.period.Period.start_time"T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-week&pandas._libs.tslibs.period.Period.week"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-weekday)pandas._libs.tslibs.period.Period.weekday"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-
-weekofyear,pandas._libs.tslibs.period.Period.weekofyear"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-year&pandas._libs.tslibs.period.Period.year"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-day_of_year-pandas._libs.tslibs.period.Period.day_of_year"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-day_of_week-pandas._libs.tslibs.period.Period.day_of_week"
-builtins.int"builtins.int*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:builtins.property`*
-asfreq(pandas._libs.tslibs.period.Period.asfreq"F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
-freq
-:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
-builtins.str"builtins.strP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
-how
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Mapping*
+argsort!pandas.core.series.Series.argsort"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str")pandas._libs.tslibs.period._PeriodFreqHow *
-now%pandas._libs.tslibs.period.Period.now"F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
-clsy
-'Type[pandas._libs.tslibs.period.Period]F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period"type*
-freq
-:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
-builtins.str"builtins.strP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset 0:builtins.classmethodp*
-strftime*pandas._libs.tslibs.period.Period.strftime"
-builtins.str"builtins.str*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*%
-fmt
-builtins.str"builtins.str*
-to_timestamp.pandas._libs.tslibs.period.Period.to_timestamp"T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*P
-selfF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
-freq
-?Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset,None]
-builtins.str"builtins.strP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
-None *
-how
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]	
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+kind
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
 ^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
@@ -20902,704 +28393,609 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str")pandas._libs.tslibs.period._PeriodFreqHow7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.SortKind *
+order
+None **
+nlargest"pandas.core.series.Series.nlargest"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+n
+builtins.int"builtins.int *
+keep
+ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.NaPosition7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str **
+	nsmallest#pandas.core.series.Series.nsmallest"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+n
+builtins.int"builtins.int *
+keep
+ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.NaPosition7
 Literal[builtins.str]	
-builtins.str"builtins.str"0pandas._libs.tslibs.period._PeriodToTimestampHow 2
-__sub__)pandas._libs.tslibs.period.Period.__sub__
-__sub__)pandas._libs.tslibs.period.Period.__sub__"F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
-TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]]
-Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
-datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64
-4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
-)numpy.signedinteger[numpy._typing._64Bit],
-numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64
-builtins.int"builtins.intP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"(pandas._libs.tslibs.period._PeriodAddSub0:typing.overloadX
-__sub__)pandas._libs.tslibs.period.Period.__sub__"P
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
-__sub__)pandas._libs.tslibs.period.Period.__sub__"J
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*LJ
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
-__sub__)pandas._libs.tslibs.period.Period.__sub__"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
-__sub__)pandas._libs.tslibs.period.Period.__sub__"B
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
-__sub__)pandas._libs.tslibs.period.Period.__sub__"P
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*`^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex0:typing.overloadX2
-__add__)pandas._libs.tslibs.period.Period.__add__
-__add__)pandas._libs.tslibs.period.Period.__add__"F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
-TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]]
-Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
-datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64
-4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
-)numpy.signedinteger[numpy._typing._64Bit],
-numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64
-builtins.int"builtins.intP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"(pandas._libs.tslibs.period._PeriodAddSub0:typing.overloadX
-__add__)pandas._libs.tslibs.period.Period.__add__"J
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*LJ
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
-__add__)pandas._libs.tslibs.period.Period.__add__"P
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*PN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index0:typing.overloadX
-__add__)pandas._libs.tslibs.period.Period.__add__"B
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
-IUnion[pandas.core.series.OffsetSeries,pandas.core.series.TimedeltaSeries]B
-pandas.core.series.OffsetSeries"pandas.core.series.OffsetSeriesH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX2
-__eq__(pandas._libs.tslibs.period.Period.__eq__
-__eq__(pandas._libs.tslibs.period.Period.__eq__"
-
builtins.bool"
builtins.bool*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
-__eq__(pandas._libs.tslibs.period.Period.__eq__"
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
-__eq__(pandas._libs.tslibs.period.Period.__eq__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX
-__eq__(pandas._libs.tslibs.period.Period.__eq__":
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*$"
-builtins.object"builtins.object0:typing.overloadX2	
-__ge__(pandas._libs.tslibs.period.Period.__ge__
-__ge__(pandas._libs.tslibs.period.Period.__ge__"
-
builtins.bool"
builtins.bool*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
-__ge__(pandas._libs.tslibs.period.Period.__ge__"
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
-__ge__(pandas._libs.tslibs.period.Period.__ge__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX2	
-__gt__(pandas._libs.tslibs.period.Period.__gt__
-__gt__(pandas._libs.tslibs.period.Period.__gt__"
-
builtins.bool"
builtins.bool*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
-__gt__(pandas._libs.tslibs.period.Period.__gt__"
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
-__gt__(pandas._libs.tslibs.period.Period.__gt__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX2	
-__le__(pandas._libs.tslibs.period.Period.__le__
-__le__(pandas._libs.tslibs.period.Period.__le__"
-
builtins.bool"
builtins.bool*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
-__le__(pandas._libs.tslibs.period.Period.__le__"
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
-__le__(pandas._libs.tslibs.period.Period.__le__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX2	
-__lt__(pandas._libs.tslibs.period.Period.__lt__
-__lt__(pandas._libs.tslibs.period.Period.__lt__"
-
builtins.bool"
builtins.bool*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
-__lt__(pandas._libs.tslibs.period.Period.__lt__"
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
-__lt__(pandas._libs.tslibs.period.Period.__lt__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX2
-__ne__(pandas._libs.tslibs.period.Period.__ne__
-__ne__(pandas._libs.tslibs.period.Period.__ne__"
-
builtins.bool"
builtins.bool*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
-__ne__(pandas._libs.tslibs.period.Period.__ne__"
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:typing.overloadX
-__ne__(pandas._libs.tslibs.period.Period.__ne__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*DB
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries0:typing.overloadX
-__ne__(pandas._libs.tslibs.period.Period.__ne__":
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*$"
-builtins.object"builtins.object0:typing.overloadX2
-__radd__*pandas._libs.tslibs.period.Period.__radd__
-__radd__*pandas._libs.tslibs.period.Period.__radd__"F
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*
-TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]]
-Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
-datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64
-4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
-)numpy.signedinteger[numpy._typing._64Bit],
-numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64
-builtins.int"builtins.intP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"(pandas._libs.tslibs.period._PeriodAddSub0:typing.overloadX
-__radd__*pandas._libs.tslibs.period.Period.__radd__"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*PN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index0:typing.overloadX
-__radd__*pandas._libs.tslibs.period.Period.__radd__"B
-pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX
-__radd__*pandas._libs.tslibs.period.Period.__radd__"J
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period*LJ
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
-PeriodDtype%pandas.core.dtypes.dtypes.PeriodDtype".pandas.core.dtypes.dtypes.PandasExtensionDtype*
-__init__.pandas.core.dtypes.dtypes.PeriodDtype.__init__"
-None*X
-selfN
-%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype*
-freq
-:Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
-builtins.str"builtins.strP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset *
-freq*pandas.core.dtypes.dtypes.PeriodDtype.freq"P
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*X
-selfN
-%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype0:builtins.property`*
-na_value.pandas.core.dtypes.dtypes.PeriodDtype.na_value"J
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*X
-selfN
-%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype0:builtins.property`A
-PeriodIndex&pandas.core.indexes.period.PeriodIndex"6pandas.core.indexes.datetimelike.DatetimeIndexOpsMixin"1pandas.core.indexes.accessors.PeriodIndexFieldOps*
-__new__.pandas.core.indexes.period.PeriodIndex.__new__"
-Any*
-cls
-,Type[pandas.core.indexes.period.PeriodIndex]P
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"type*
-data
-Any *
-ordinal
-Any *
-freq
-Any *
-tz
-Any *
-dtype
-Any **
-copy
-
builtins.bool"
builtins.bool *
-name
-Any *
-fields
-Any*X
-values-pandas.core.indexes.period.PeriodIndex.values*
-self0:builtins.property`*
-__contains__3pandas.core.indexes.period.PeriodIndex.__contains__"
-
builtins.bool"
builtins.bool*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*	
-Any*
-	__array__0pandas.core.indexes.period.PeriodIndex.__array__"9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-dtype
-Any *l
-__array_wrap__5pandas.core.indexes.period.PeriodIndex.__array_wrap__*
-self*
-
-result*
-context *\
-	asof_locs0pandas.core.indexes.period.PeriodIndex.asof_locs*
-self*	
-where*
-mask*
-astype-pandas.core.indexes.period.PeriodIndex.astype"
-Any*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-dtype
-Any**
-copy
-
builtins.bool"
builtins.bool *'
-how
-builtins.str"builtins.str *
-searchsorted3pandas.core.indexes.period.PeriodIndex.searchsorted"
-Any*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-value
-Any*(
-side
-builtins.str"builtins.str *
-sorter
-Any *
-is_full.pandas.core.indexes.period.PeriodIndex.is_full"
-
builtins.bool"
builtins.bool*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`*
-
inferred_type4pandas.core.indexes.period.PeriodIndex.inferred_type"
-builtins.str"builtins.str*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`*\
-	get_value0pandas.core.indexes.period.PeriodIndex.get_value*
-self*
-
-series*
-key*
-get_indexer2pandas.core.indexes.period.PeriodIndex.get_indexer*
-self*
-
-target*
-method *
-limit *
-	tolerance *m
-get_indexer_non_unique=pandas.core.indexes.period.PeriodIndex.get_indexer_non_unique*
-self*
-
-target*]
-get_loc.pandas.core.indexes.period.PeriodIndex.get_loc*
-self*
-key*
-	tolerance *T
-insert-pandas.core.indexes.period.PeriodIndex.insert*
-self*
-loc*
-item*
-join+pandas.core.indexes.period.PeriodIndex.join"
-Any*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-other
-Any*'
-how
-builtins.str"builtins.str *
-level
-Any *5
-return_indexers
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool *
-intersection3pandas.core.indexes.period.PeriodIndex.intersection"
-Any*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*
-other
-Any**
-sort
-
builtins.bool"
builtins.bool *`
-
-difference1pandas.core.indexes.period.PeriodIndex.difference*
-self*	
-other*
-
-sort *
-memory_usage3pandas.core.indexes.period.PeriodIndex.memory_usage"
-Any*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex**
-deep
-
builtins.bool"
builtins.bool *
-freqstr.pandas.core.indexes.period.PeriodIndex.freqstr"
-builtins.str"builtins.str*Z
-selfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex0:builtins.property`2
-__sub__.pandas.core.indexes.period.PeriodIndex.__sub__
-__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
-__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-+pandas.core.indexes.period.PeriodIndex.SelfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
-+pandas.core.indexes.period.PeriodIndex.SelfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(0:typing.overloadX
-
-__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"
-+pandas.core.indexes.period.PeriodIndex.SelfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
-+pandas.core.indexes.period.PeriodIndex.SelfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
-TypeAlias[Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]]
-Union[pandas._libs.tslibs.timedeltas.Timedelta,datetime.timedelta,numpy.timedelta64,TypeAlias[numpy.signedinteger[numpy._typing._64Bit]],builtins.int,pandas._libs.tslibs.offsets.BaseOffset]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
-datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64
-4TypeAlias[numpy.signedinteger[numpy._typing._64Bit]]n
-)numpy.signedinteger[numpy._typing._64Bit],
-numpy._typing._64Bit"numpy._typing._64Bit"numpy.signedinteger"numpy.int64
-builtins.int"builtins.intP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"(pandas._libs.tslibs.period._PeriodAddSub0:typing.overloadX
-__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"J
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*LJ
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadX
-__sub__.pandas.core.indexes.period.PeriodIndex.__sub__"
-+pandas.core.indexes.period.PeriodIndex.SelfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
-+pandas.core.indexes.period.PeriodIndex.SelfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
-]Union[pandas.core.indexes.timedeltas.TimedeltaIndex,pandas._libs.tslibs.timedeltas.Timedelta]^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndexT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta0:typing.overloadX2	
-__rsub__/pandas.core.indexes.period.PeriodIndex.__rsub__
-__rsub__/pandas.core.indexes.period.PeriodIndex.__rsub__"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*HF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period0:typing.overloadX
-__rsub__/pandas.core.indexes.period.PeriodIndex.__rsub__"N
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*
-+pandas.core.indexes.period.PeriodIndex.SelfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(*
-+pandas.core.indexes.period.PeriodIndex.SelfP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex(0:typing.overloadX
-__rsub__/pandas.core.indexes.period.PeriodIndex.__rsub__"J
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType*RP
-&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*LJ
-#pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType0:typing.overloadXI
-
-RangeIndex$pandas.core.indexes.range.RangeIndex"pandas.core.indexes.base.Index*
-__new__,pandas.core.indexes.range.RangeIndex.__new__"
-Any*
-cls
-*Type[pandas.core.indexes.range.RangeIndex]L
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex"type*
-start
-8Union[builtins.int,pandas.core.indexes.range.RangeIndex]
-builtins.int"builtins.intL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex *(
-stop
-builtins.int"builtins.int *(
-step
-builtins.int"builtins.int *
-dtype
-Any **
-copy
-
builtins.bool"
builtins.bool *
-name
-Any *
-__init__-pandas.core.indexes.range.RangeIndex.__init__"
-None*V
-selfL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex*
-start
-8Union[builtins.int,pandas.core.indexes.range.RangeIndex]
-builtins.int"builtins.intL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex *(
-stop
-builtins.int"builtins.int *(
-step
-builtins.int"builtins.int *
-dtype
-Any **
+builtins.str"builtins.str **
+	swaplevel#pandas.core.series.Series.swaplevel"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+i
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level *
+j
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level **
 copy
-
builtins.bool"
builtins.bool *
-name
-Any *
-
-from_range/pandas.core.indexes.range.RangeIndex.from_range*
-cls*
-data*
-
-name *
-dtype 0:builtins.classmethodp*G
-
-__reduce__/pandas.core.indexes.range.RangeIndex.__reduce__*
-self*=
-start*pandas.core.indexes.range.RangeIndex.start*
-self*;
-stop)pandas.core.indexes.range.RangeIndex.stop*
-self*;
-step)pandas.core.indexes.range.RangeIndex.step*
-self*
-nbytes+pandas.core.indexes.range.RangeIndex.nbytes"
-builtins.int"builtins.int*V
-selfL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex0:builtins.property`*
-memory_usage1pandas.core.indexes.range.RangeIndex.memory_usage"
-builtins.int"builtins.int*V
-selfL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex**
-deep
-
builtins.bool"
builtins.bool *
-dtype*pandas.core.indexes.range.RangeIndex.dtype"(
-numpy.dtype[Any]
-Any"numpy.dtype*V
-selfL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex0:builtins.property`*
-	is_unique.pandas.core.indexes.range.RangeIndex.is_unique"
-
builtins.bool"
builtins.bool*V
-selfL
-$pandas.core.indexes.range.RangeIndex"$pandas.core.indexes.range.RangeIndex0:builtins.property`*
-is_monotonic_increasing
+interpolate%pandas.core.series.Series.interpolate"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23358,18 +31251,15 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23396,24 +31286,112 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+method
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.InterpolateOptions *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *-
+inplace
+
builtins.bool"
builtins.bool *
+limit_direction
+MUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+
+limit_area
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *x
+downcasth
+!Union[Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None *
+kwargs
+Any*I
+asofpandas.core.series.Series.asof"#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*W
-min_periodsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *(
-ddof
-builtins.int"builtins.int *.
-diffpandas.core.series.Series.diff"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23440,18 +31418,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23478,22 +31453,42 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+where
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],typing.Sequence[Unknown]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int *
-autocorr"pandas.core.series.Series.autocorr" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar-
+typing.Sequence[Unknown]"typing.Sequence*
+subset
+6Union[builtins.str,typing.Sequence[builtins.str],None]
+builtins.str"builtins.strN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+None *4
+clippandas.core.series.Series.clip"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23520,23 +31515,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-lag
-builtins.int"builtins.int *6
-
-__matmul__$pandas.core.series.Series.__matmul__***8
-__rmatmul__%pandas.core.series.Series.__rmatmul__***U
-combine!pandas.core.series.Series.combine"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23563,18 +31550,54 @@ __matmul__$pandas.core.series.Series.__matmul__***8
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+lower
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.float,None]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike 
+builtins.float"builtins.float
+None *
+upper
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.float,None]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *-
+inplace
+
builtins.bool"
builtins.bool *
+kwargs
+Any*=
+asfreq pandas.core.series.Series.asfreq"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23601,18 +31624,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23639,17 +31659,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+freq
+Any*
+method
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FillnaOptions
+None *
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None */
+	normalize
+
builtins.bool"
builtins.bool *
 
 fill_value
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],None]
@@ -23671,11 +31709,11 @@ fill_value
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
 builtins.complex"builtins.complex"pandas._typing.Scalar
-None *E
-
combine_first'pandas.core.series.Series.combine_first"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *+
+at_time!pandas.core.series.Series.at_time"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23702,18 +31740,15 @@ fill_value
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23740,18 +31775,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-other
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*m
+timec
+!Union[builtins.str,datetime.time]
+builtins.str"builtins.str
+
datetime.time"
datetime.time**
+asof
+
builtins.bool"
builtins.bool *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *+
+between_time&pandas.core.series.Series.between_time"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23778,20 +31825,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*]
-update pandas.core.series.Series.update"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23818,19 +31860,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*E
-otherE
-Union[pandas.core.series.Series[pandas._typing.S1],typing.Sequence[pandas._typing.S1],typing.Mapping[builtins.int,pandas._typing.S1]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*s
+
+start_timec
+!Union[builtins.str,datetime.time]
+builtins.str"builtins.str
+
datetime.time"
datetime.time*q
+end_timec
+!Union[builtins.str,datetime.time]
+builtins.str"builtins.str
+
datetime.time"
datetime.time*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *'
+firstpandas.core.series.Series.first"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23857,17 +31913,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-"typing.Sequence[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23894,18 +31948,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Sequence
-.typing.Mapping[builtins.int,pandas._typing.S1]
-builtins.int"builtins.int
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+offset
+Any*'
+lastpandas.core.series.Series.last"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23932,21 +31985,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"typing.Mapping*
-argsort!pandas.core.series.Series.argsort"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -23973,24 +32020,60 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+offset
+Any*
+rankpandas.core.series.Series.rank"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+method
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -23998,13 +32081,27 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-order
-None *1
-nlargest"pandas.core.series.Series.nlargest"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *2
+numeric_only
+
builtins.bool"
builtins.bool *
+	na_option
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str */
+	ascending
+
builtins.bool"
builtins.bool *)
+pct
+
builtins.bool"
builtins.bool *C
+wherepandas.core.series.Series.where"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24031,18 +32128,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24069,30 +32163,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*%
-n
-builtins.int"builtins.int *
-keep
-ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition7
-Literal[builtins.str]	
-builtins.str"builtins.str *1
-	nsmallest#pandas.core.series.Series.nsmallest"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+cond
+Union[pandas.core.series.Series[pandas._typing.S1],pandas.core.series.Series[builtins.bool],numpy.ndarray[Any,Any],CallableType[builtins.function],CallableType[builtins.function]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24119,18 +32199,44 @@ ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[bui
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Seriese
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayK
+CallableType[builtins.function]&
+builtins.function"builtins.functionK
+CallableType[builtins.function]&
+builtins.function"builtins.function*
+other
+Any *-
+inplace
+
builtins.bool"
builtins.bool *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *i
+maskpandas.core.series.Series.mask"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24157,30 +32263,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*%
-n
-builtins.int"builtins.int *
-keep
-ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition7
-Literal[builtins.str]	
-builtins.str"builtins.str *1
-	swaplevel#pandas.core.series.Series.swaplevel"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24207,18 +32298,16 @@ ZUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],Literal[bui
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+cond
+Union[pandas.core.series.Series[pandas._typing.S1],pandas.core.series.Series[builtins.bool],numpy.ndarray[Any,Any],CallableType[builtins.function],CallableType[builtins.function]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24245,30 +32334,43 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Seriese
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayK
+CallableType[builtins.function]&
+builtins.function"builtins.functionK
+CallableType[builtins.function]&
+builtins.function"builtins.function*%
+other%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,CallableType[builtins.function],pandas._libs.missing.NAType,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-i
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level *
-j
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level **
-copy
-
builtins.bool"
builtins.bool *.
-reorder_levels(pandas.core.series.Series.reorder_levels"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24295,18 +32397,41 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrameK
+CallableType[builtins.function]&
+builtins.function"builtins.function:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType
+None *-
+inplace
+
builtins.bool"
builtins.bool *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *6
+	case_when#pandas.core.series.Series.case_when"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24333,21 +32458,57 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*"
+caselist"
+builtins.list[Tuple[Union[typing.Sequence[builtins.bool],pandas.core.series.Series[builtins.bool],CallableType[builtins.function]],Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],CallableType[builtins.function]]]]
+Tuple[Union[typing.Sequence[builtins.bool],pandas.core.series.Series[builtins.bool],CallableType[builtins.function]],Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],CallableType[builtins.function]]]
+nUnion[typing.Sequence[builtins.bool],pandas.core.series.Series[builtins.bool],CallableType[builtins.function]]Q
+typing.Sequence[builtins.bool]
+
builtins.bool"
builtins.bool"typing.Sequencee
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.SeriesK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+Union[TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],CallableType[builtins.function]]
+TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
+uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
+typing.Sequence[Any]
+Any"typing.Sequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarrayD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.SeriesN
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*7
-order,
-builtins.list[Any]
-Any"
builtins.list*.
-explode!pandas.core.series.Series.explode"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.ScalarK
+CallableType[builtins.function]&
+builtins.function"builtins.function"
builtins.list*,
+truncate"pandas.core.series.Series.truncate"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24374,18 +32535,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24412,20 +32570,39 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-unstack!pandas.core.series.Series.unstack":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+before
+3Union[datetime.date,builtins.str,builtins.int,None]
+
datetime.date"
datetime.date
+builtins.str"builtins.str
+builtins.int"builtins.int
+None *
+after
+3Union[datetime.date,builtins.str,builtins.int,None]
+
datetime.date"
datetime.date
+builtins.str"builtins.str
+builtins.int"builtins.int
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None **
+copy
+
builtins.bool"
builtins.bool *+
+
+tz_convert$pandas.core.series.Series.tz_convert"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24452,32 +32629,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level *
-
-fill_value
-Union[pandas._typing.S1,builtins.list[pandas._typing.S1],None]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24953,21 +32993,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-values
-_Union[typing.Iterable[Any],pandas.core.series.Series[pandas._typing.S1],builtins.dict[Any,Any]]0
-typing.Iterable[Any]
-Any"typing.Iterable
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -24994,24 +33027,17 @@ _Union[typing.Iterable[Any],pandas.core.series.Series[pandas._typing.S1],builtin
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict*E
-between!pandas.core.series.Series.between"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list
+None *(
+
+pct_change$pandas.core.series.Series.pct_change"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25038,47 +33064,59 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-left
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
-uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU*
-right
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*+
+periods
+builtins.int"builtins.int */
+fill_method
+builtins.str"builtins.str *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+freq
+Any *
+kwargs
+Any*!
+first_valid_index+pandas.core.series.Series.first_valid_index"
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -25096,35 +33134,11 @@ uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-TypeAlias[Union[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]]
-uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"pandas._typing.ListLikeU*
-	inclusive
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *
-isnapandas.core.series.Series.isna"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25151,21 +33165,34 @@ uUnion[typing.Sequence[Any],numpy.ndarray[Any,Any],pandas.core.series.Series[Any
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*!
+last_valid_index*pandas.core.series.Series.last_valid_index"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-isnull pandas.core.series.Series.isnull"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25192,21 +33219,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-notnapandas.core.series.Series.notna"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*'
+	transpose#pandas.core.series.Series.transpose"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25233,21 +33254,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-notnull!pandas.core.series.Series.notnull"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25274,18 +33289,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*2
-to_timestamp&pandas.core.series.Series.to_timestamp"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+args
+Any*
+kwargs
+Any*(
+Tpandas.core.series.Series.T"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25312,18 +33329,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25350,35 +33365,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-freq
-Any *
-how
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str""pandas._typing.TimestampConvention **
-copy
-
builtins.bool"
builtins.bool *
-	to_period#pandas.core.series.Series.to_period":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(0:builtins.property`*k
+__div__!pandas.core.series.Series.__div__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25405,29 +33400,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-freqD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None **
-copy
-
builtins.bool"
builtins.bool *
-strpandas.core.series.Series.str"
-]pandas.core.strings.StringMethods[pandas.core.series.Series[Any],pandas.core.frame.DataFrame]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"!pandas.core.strings.StringMethods*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -25454,20 +33435,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
-dtpandas.core.series.Series.dt"|
-pandas.core.resample.Resampler[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"pandas.core.resample.Resampler*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27707,87 +35285,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-rule
-Any*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *R
-closedD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *Q
-labelD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *
-
-convention
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str""pandas._typing.TimestampConvention *
-kind
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None *
-loffset
-Any *(
-base
-builtins.int"builtins.int *N
-onD
-Union[builtins.str,None]
-builtins.str"builtins.str
-None *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-origin
-Union[pandas._libs.tslibs.timestamps.Timestamp,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *
-offset
-AUnion[pandas._libs.tslibs.timedeltas.Timedelta,builtins.str,None]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
-builtins.str"builtins.str
-None *.
-firstpandas.core.series.Series.first"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+
__rfloordiv__'pandas.core.series.Series.__rfloordiv__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27814,18 +35320,14 @@ AUnion[pandas._libs.tslibs.timedeltas.Timedelta,builtins.str,None]T
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27852,20 +35354,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-offset
-Any*.
-lastpandas.core.series.Series.last"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27892,18 +35403,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27930,23 +35437,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-offset
-Any* 
-rankpandas.core.series.Series.rank"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -27973,51 +35471,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-method
-tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *2
-numeric_only
-
builtins.bool"
builtins.bool *
-	na_option
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str */
-	ascending
-
builtins.bool"
builtins.bool *)
-pct
-
builtins.bool"
builtins.bool *N
-wherepandas.core.series.Series.where"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+__rmod__"pandas.core.series.Series.__rmod__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28044,18 +35506,14 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28082,19 +35540,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-cond
-Union[pandas.core.series.Series[pandas._typing.S1],pandas.core.series.Series[builtins.bool],numpy.ndarray[Any,Any],CallableType[builtins.function],CallableType[builtins.function]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28121,49 +35589,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Seriese
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarrayK
-CallableType[builtins.function]&
-builtins.function"builtins.functionK
-CallableType[builtins.function]&
-builtins.function"builtins.function*
-other
-Any *-
-inplace
-
builtins.bool"
builtins.bool *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-try_cast
-
builtins.bool"
builtins.bool *e
-maskpandas.core.series.Series.mask"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28190,18 +35623,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28228,51 +35657,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-cond
-TypeAlias[Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]]
-Union[pandas.core.series.Series[builtins.bool],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],builtins.list[builtins.bool]]e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.list"pandas._typing.MaskType*)
-other)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,CallableType[builtins.function],pandas._libs.missing.NAType,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+__rnatmul__%pandas.core.series.Series.__rnatmul__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28299,43 +35692,15 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrameK
-CallableType[builtins.function]&
-builtins.function"builtins.function:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType
-None *-
-inplace
-
builtins.bool"
builtins.bool *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *.
-try_cast
-
builtins.bool"
builtins.bool *0
-slice_shift%pandas.core.series.Series.slice_shift"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28362,18 +35727,30 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28400,27 +35777,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *0
-tshift pandas.core.series.Series.tshift"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28447,18 +35811,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28485,29 +35845,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int *
-freq
-Any *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *4
-truncate"pandas.core.series.Series.truncate"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*k
+__rpow__"pandas.core.series.Series.__rpow__"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28534,18 +35880,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28572,42 +35914,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-before
-3Union[datetime.date,builtins.str,builtins.int,None]
-
datetime.date"
datetime.date
-builtins.str"builtins.str
-builtins.int"builtins.int
-None *
-after
-3Union[datetime.date,builtins.str,builtins.int,None]
-
datetime.date"
datetime.date
-builtins.str"builtins.str
-builtins.int"builtins.int
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None **
-copy
-
builtins.bool"
builtins.bool *2
-
-tz_convert$pandas.core.series.Series.tz_convert"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28634,18 +35963,14 @@ tz_convert$pandas.core.series.Series.tz_convert"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28672,36 +35997,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-tz
-Any*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None **
-copy
-
builtins.bool"
builtins.bool *3
-tz_localize%pandas.core.series.Series.tz_localize"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28728,18 +36031,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*X
+__rsub__"pandas.core.series.Series.__rsub__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28766,40 +36068,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-tz
-Any*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None **
-copy
-
builtins.bool"
builtins.bool *
-	ambiguous
-Any */
-nonexistent
-builtins.str"builtins.str *.
-abspandas.core.series.Series.abs"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28826,18 +36117,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28864,18 +36151,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*u
-describe"pandas.core.series.Series.describe"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28902,18 +36185,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*X
+__rtruediv__&pandas.core.series.Series.__rtruediv__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28940,26 +36222,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-percentiles
-)Union[builtins.list[builtins.float],None]P
-builtins.list[builtins.float] 
-builtins.float"builtins.float"
builtins.list
-None *
-include
-BUnion[Literal[builtins.str],builtins.list[pandas._typing.S1],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -28986,19 +36271,14 @@ BUnion[Literal[builtins.str],builtins.list[pandas._typing.S1],None]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-None *-
-exclude-
->Union[pandas._typing.S1,builtins.list[pandas._typing.S1],None]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29025,17 +36305,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
- builtins.list[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29062,24 +36339,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"
builtins.list
-None *b
-datetime_is_numericG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None */
-
-pct_change$pandas.core.series.Series.pct_change"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*X
+__truediv__%pandas.core.series.Series.__truediv__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29106,18 +36376,29 @@ pct_change$pandas.core.series.Series.pct_change"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*DD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29144,49 +36425,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*+
-periods
-builtins.int"builtins.int */
-fill_method
-builtins.str"builtins.str *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-freq
-Any *
-kwargs
-Any*$
-first_valid_index+pandas.core.series.Series.first_valid_index"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29213,37 +36459,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$
-last_valid_index*pandas.core.series.Series.last_valid_index"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29270,21 +36493,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-value_counts&pandas.core.series.Series.value_counts"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+__invert__$pandas.core.series.Series.__invert__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29311,30 +36531,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*/
-	normalize
-
builtins.bool"
builtins.bool **
-sort
-
builtins.bool"
builtins.bool */
-	ascending
-
builtins.bool"
builtins.bool *P
-binsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *,
-dropna
-
builtins.bool"
builtins.bool *.
-	transpose#pandas.core.series.Series.transpose"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+atpandas.core.series.Series.at"B
+pandas.core.indexing._AtIndexer"pandas.core.indexing._AtIndexer*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29361,18 +36568,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
+catpandas.core.series.Series.cat"h
+2pandas.core.arrays.categorical.CategoricalAccessor"2pandas.core.arrays.categorical.CategoricalAccessor*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29399,22 +36605,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-args
-Any*
-kwargs
-Any*.
-Tpandas.core.series.Series.T"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*
+iatpandas.core.series.Series.iat"D
+ pandas.core.indexing._iAtIndexer" pandas.core.indexing._iAtIndexer*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29441,18 +36642,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*'
+ilocpandas.core.series.Series.iloc"
+8pandas.core.series._iLocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29479,18 +36677,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*P
-__div__!pandas.core.series.Series.__div__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"%pandas.core.series._iLocIndexerSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29517,18 +36712,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*'
+locpandas.core.series.Series.loc"
+7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29555,39 +36747,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"$pandas.core.series._LocIndexerSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29614,20 +36782,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-__eq__ pandas.core.series.Series.__eq__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:builtins.property`*M
+addpandas.core.series.Series.add"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29654,21 +36817,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$"
-builtins.object"builtins.object*:
-__floordiv__&pandas.core.series.Series.__floordiv__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29695,38 +36852,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29753,20 +36888,49 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*Q
-__ge__ pandas.core.series.Series.__ge__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *(
+axis
+builtins.int"builtins.int *
+allpandas.core.series.Series.all"
+
builtins.bool"
builtins.bool*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29793,17 +36957,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+anypandas.core.series.Series.any"
+
builtins.bool"
builtins.bool*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29830,36 +37009,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *X
+	bool_onlyG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+kwargs
+Any**
+cummax pandas.core.series.Series.cummax"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29886,22 +37059,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*Q
-__gt__ pandas.core.series.Series.__gt__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29928,17 +37094,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+args
+Any*
+kwargs
+Any**
+cummin pandas.core.series.Series.cummin"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -29965,36 +37144,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30020,23 +37178,31 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 Type[builtins.object]"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*Q
-__le__ pandas.core.series.Series.__le__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+args
+Any*
+kwargs
+Any**
+cumprod!pandas.core.series.Series.cumprod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30063,17 +37229,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30100,36 +37264,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+args
+Any*
+kwargs
+Any**
+cumsum pandas.core.series.Series.cumsum"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30156,22 +37314,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*Q
-__lt__ pandas.core.series.Series.__lt__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30198,17 +37349,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*99
-Union[pandas._typing.S1,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],datetime.datetime,datetime.timedelta]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+args
+Any*
+kwargs
+Any*]
+divide pandas.core.series.Series.divide"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30235,16 +37402,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -30255,16 +37422,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30291,20 +37452,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta*P
-__mod__!pandas.core.series.Series.__mod__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30331,17 +37486,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30368,38 +37520,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *p
+divmod pandas.core.series.Series.divmod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30426,20 +37574,15 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-__ne__ pandas.core.series.Series.__ne__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30466,19 +37609,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$"
-builtins.object"builtins.object*P
-__pow__!pandas.core.series.Series.__pow__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30505,17 +37659,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30542,38 +37693,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30600,18 +37727,37 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__radd__"pandas.core.series.Series.__radd__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *=
+eqpandas.core.series.Series.eq"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30638,17 +37784,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30675,39 +37838,38 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,builtins.str,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-builtins.str"builtins.str
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+ewmpandas.core.series.Series.ewm"
+Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30734,18 +37896,41 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rdiv__"pandas.core.series.Series.__rdiv__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*U
+comJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *V
+spanJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *Z
+halflifeJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *W
+alphaJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None */
+min_periods
+builtins.int"builtins.int *,
+adjust
+
builtins.bool"
builtins.bool */
+	ignore_na
+
builtins.bool"
builtins.bool *
+	expanding#pandas.core.series.Series.expanding"
+Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30772,17 +37957,27 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*/
+min_periods
+builtins.int"builtins.int *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod *^
+floordiv"pandas.core.series.Series.floordiv"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30809,18 +38004,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -30831,16 +38024,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30867,18 +38054,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rdivmod__%pandas.core.series.Series.__rdivmod__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30905,18 +38088,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -30943,39 +38122,39 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *=
+gepandas.core.series.Series.ge"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31002,18 +38181,34 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-
__rfloordiv__'pandas.core.series.Series.__rfloordiv__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31040,17 +38235,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *=
+gtpandas.core.series.Series.gt"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31077,38 +38292,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31135,18 +38346,33 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rmod__"pandas.core.series.Series.__rmod__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *&
+itempandas.core.series.Series.item"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31173,17 +38399,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31210,38 +38434,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+kurtpandas.core.series.Series.kurt"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31268,20 +38488,51 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*%
+kurtosis"pandas.core.series.Series.kurtosis"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*#
-__rmul__"pandas.core.series.Series.__rmul__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31308,41 +38559,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[Any]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLikeD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*P
-__rnatmul__%pandas.core.series.Series.__rnatmul__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*=
+lepandas.core.series.Series.le"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31369,18 +38614,34 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31407,39 +38668,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *=
+ltpandas.core.series.Series.lt"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31466,18 +38725,34 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*P
-__rpow__"pandas.core.series.Series.__rpow__"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31504,17 +38779,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex **
+maxpandas.core.series.Series.max"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31541,38 +38832,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31599,20 +38867,34 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*:
-__rsub__"pandas.core.series.Series.__rsub__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+meanpandas.core.series.Series.mean" 
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31639,38 +38921,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*
+median pandas.core.series.Series.median" 
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31697,20 +38975,31 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*:
-__truediv__%pandas.core.series.Series.__truediv__"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any**
+minpandas.core.series.Series.min"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31737,38 +39026,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31795,21 +39061,32 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-__invert__$pandas.core.series.Series.__invert__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *,
+skipna
+
builtins.bool"
builtins.bool *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*q
+modpandas.core.series.Series.mod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31836,20 +39113,15 @@ __invert__$pandas.core.series.Series.__invert__"e
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-atpandas.core.series.Series.at"B
-pandas.core.indexing._AtIndexer"pandas.core.indexing._AtIndexer*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31876,20 +39148,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
-catpandas.core.series.Series.cat"h
-2pandas.core.arrays.categorical.CategoricalAccessor"2pandas.core.arrays.categorical.CategoricalAccessor*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31916,20 +39198,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*
-iatpandas.core.series.Series.iat"D
- pandas.core.indexing._iAtIndexer" pandas.core.indexing._iAtIndexer*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31956,18 +39232,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*.
-ilocpandas.core.series.Series.iloc"
-8pandas.core.series._iLocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -31994,18 +39266,36 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"%pandas.core.series._iLocIndexerSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *q
+multiply"pandas.core.series.Series.multiply"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32032,18 +39322,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*.
-locpandas.core.series.Series.loc"
-7pandas.core.series._LocIndexerSeries[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32070,18 +39357,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"$pandas.core.series._LocIndexerSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32108,18 +39407,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:builtins.property`*X
-addpandas.core.series.Series.add"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32146,18 +39441,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32184,19 +39475,39 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *=
+nepandas.core.series.Series.ne"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32223,14 +39534,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -32248,27 +39558,10 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *(
-axis
-builtins.int"builtins.int *
-allpandas.core.series.Series.all"
-
builtins.bool"
builtins.bool*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32295,35 +39588,36 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any*
-anypandas.core.series.Series.any"
-
builtins.bool"
builtins.bool*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+nunique!pandas.core.series.Series.nunique"
+builtins.int"builtins.int*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32350,33 +39644,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *X
-	bool_onlyG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-kwargs
-Any*1
-cummax pandas.core.series.Series.cummax"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*,
+dropna
+
builtins.bool"
builtins.bool *q
+powpandas.core.series.Series.pow"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32403,18 +39681,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32441,33 +39716,30 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*1
-cummin pandas.core.series.Series.cummin"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32494,18 +39766,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32532,33 +39800,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*1
-cumprod!pandas.core.series.Series.cumprod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32585,18 +39834,55 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *%
+prodpandas.core.series.Series.prod"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32623,14 +39909,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -32639,17 +39922,42 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *-
+	min_count
+builtins.int"builtins.int *
 kwargs
-Any*1
-cumsum pandas.core.series.Series.cumsum"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*%
+product!pandas.core.series.Series.product"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.floatT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32676,18 +39984,36 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *-
+	min_count
+builtins.int"builtins.int *
+kwargs
+Any*O
+raddpandas.core.series.Series.radd"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32714,36 +40040,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-args
-Any*
-kwargs
-Any*?
-divide pandas.core.series.Series.divide"h
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32770,39 +40075,16 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32829,14 +40111,29 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -32855,11 +40152,11 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *U
-divmod pandas.core.series.Series.divmod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rdivmod!pandas.core.series.Series.rdivmod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32886,18 +40183,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32924,39 +40218,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -32983,14 +40254,29 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -33009,14 +40295,11 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *D
-eqpandas.core.series.Series.eq"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *,
+	rfloordiv#pandas.core.series.Series.rfloordiv"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33043,37 +40326,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33100,14 +40361,13 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+Any*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -33126,86 +40386,11 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-ewmpandas.core.series.Series.ewm"
-Npandas.core.window.ewm.ExponentialMovingWindow[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series".pandas.core.window.ewm.ExponentialMovingWindow*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-comJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *V
-spanJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *Z
-halflifeJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *W
-alphaJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None */
-min_periods
-builtins.int"builtins.int *,
-adjust
-
builtins.bool"
builtins.bool */
-	ignore_na
-
builtins.bool"
builtins.bool *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-	expanding#pandas.core.series.Series.expanding"
-Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"&pandas.core.window.expanding.Expanding*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rmodpandas.core.series.Series.rmod"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33232,37 +40417,15 @@ Fpandas.core.window.expanding.Expanding[pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*/
-min_periods
-builtins.int"builtins.int *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod *@
-floordiv"pandas.core.series.Series.floordiv"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33289,39 +40452,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33348,14 +40488,29 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -33367,23 +40522,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fill_valueJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *D
-gepandas.core.series.Series.ge"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rpowpandas.core.series.Series.rpow"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33410,37 +40560,51 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33467,14 +40631,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -33493,14 +40672,11 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *D
-gtpandas.core.series.Series.gt"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *O
+rsubpandas.core.series.Series.rsub"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33527,37 +40703,51 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*#
+other#
+Union[pandas.core.series.Series[pandas._typing.S1],TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33584,14 +40774,29 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -33610,10 +40815,11 @@ fill_valueJ
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-itempandas.core.series.Series.item"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *,
+rtruediv"pandas.core.series.Series.rtruediv"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33640,18 +40846,15 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33678,15 +40881,33 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*(
-kurtpandas.core.series.Series.kurt"
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+Any*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *%
+sempandas.core.series.Series.sem"
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -33704,11 +40925,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33735,14 +40956,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -33751,16 +40969,20 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
 level
-None *2
+None *(
+ddof
+builtins.int"builtins.int *2
 numeric_only
 
builtins.bool"
builtins.bool *
 kwargs
-Any*(
-kurtosis"pandas.core.series.Series.kurtosis"
+Any*%
+skewpandas.core.series.Series.skew"
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -33778,11 +41000,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33809,14 +41031,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -33825,22 +41044,23 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
 level
 None *2
 numeric_only
 
builtins.bool"
builtins.bool *
 kwargs
-Any*D
-lepandas.core.series.Series.le"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any*
+stdpandas.core.series.Series.std" 
+builtins.float"builtins.float*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33867,37 +41087,155 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *(
+ddof
+builtins.int"builtins.int *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*q
+subpandas.core.series.Series.sub"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33924,14 +41262,45 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
@@ -33943,21 +41312,20 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 fill_valueJ
 Union[builtins.float,None] 
 builtins.float"builtins.float
-None *
-axis
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *D
-ltpandas.core.series.Series.lt"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *q
+subtract"pandas.core.series.Series.subtract"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -33984,37 +41352,65 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*D
+otherD
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[pandas._typing.S1]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34041,36 +41437,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *1
-maxpandas.core.series.Series.max"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34097,18 +41471,14 @@ fill_valueJ
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34135,37 +41505,36 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*
-meanpandas.core.series.Series.mean" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *&
+to_list!pandas.core.series.Series.to_list"
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34192,37 +41561,15 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*
-median pandas.core.series.Series.median" 
-builtins.float"builtins.float*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34249,34 +41596,19 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*1
-minpandas.core.series.Series.min"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*.
+to_numpy"pandas.core.series.Series.to_numpy"9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34303,18 +41635,62 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+Union[TypeAlias[Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]]],None]
+
+TypeAlias[Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]]]
+Union[numpy.dtype[Any],None,builtins.type,numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]],builtins.str,TypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]](
+numpy.dtype[Any]
+Any"numpy.dtype
+None
+
builtins.type"
builtins.type
+:numpy._typing._dtype_like._SupportsDType[numpy.dtype[Any]](
+numpy.dtype[Any]
+Any"numpy.dtype"(numpy._typing._dtype_like._SupportsDType
+builtins.str"builtins.str
+lTypeAlias[Union[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]]
+aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[TypedDict],Unknown]
+"Tuple[TypeAlias[Any],builtins.int]G
+TypeAlias[Any]
+Any"*numpy._typing._dtype_like._DTypeLikeNested
+builtins.int"builtins.int,
+builtins.list[Any]
+Any"
builtins.listM
+TypeAlias[TypedDict]
+	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike
+None **
+copy
+
builtins.bool"
builtins.bool *
+na_value
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar *
+kwargs
+Any*&
+tolist pandas.core.series.Series.tolist"
+ builtins.list[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34341,35 +41717,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *,
-skipna
-
builtins.bool"
builtins.bool *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *
-kwargs
-Any*V
-modpandas.core.series.Series.mod"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"
builtins.list*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34396,18 +41752,18 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+truediv!pandas.core.series.Series.truediv"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34434,39 +41790,55 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+Any*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *%
+varpandas.core.series.Series.var"
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34493,26 +41865,11 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -34521,11 +41878,24 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.str"builtins.str7
 Literal[builtins.int]	
 builtins.int"builtins.int"pandas._typing.AxisIndex
-None *V
-mulpandas.core.series.Series.mul"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *(
+ddof
+builtins.int"builtins.int *2
+numeric_only
+
builtins.bool"
builtins.bool *
+kwargs
+Any*/
+set_axis"pandas.core.series.Series.set_axis"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34552,18 +41922,16 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34590,39 +41958,34 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+labels
+Any*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis **
+copy
+
builtins.bool"
builtins.bool *&
+__iter__"pandas.core.series.Series.__iter__"
+"typing.Iterator[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34649,39 +42012,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *V
-multiply"pandas.core.series.Series.multiply"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Iterator*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34708,18 +42046,16 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*-
+xspandas.core.series.Series.xs"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34746,39 +42082,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
-OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
-DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike
-2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
-builtins.str"builtins.str9
-numpy.ndarray[Any,Any]
-Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34805,42 +42118,39 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*+
+key"
+typing.Hashable"typing.Hashable*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
 builtins.int"builtins.int"pandas._typing.Level
-None *\
+None *0
 
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *D
-nepandas.core.series.Series.ne"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+drop_level
+
builtins.bool"
builtins.bool 2
+__new__!pandas.core.series.Series.__new__,
+__new__!pandas.core.series.Series.__new__"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34867,37 +42177,70 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*'
-other&
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas.core.series.Series[pandas._typing.S1]]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray*
 
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *	
+dtype	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadXO
+__new__!pandas.core.series.Series.__new__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -34924,117 +42267,163 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+Union[pandas.core.indexes.datetimes.DatetimeIndex,typing.Sequence[Union[numpy.datetime64,datetime.datetime,datetime.date]],builtins.dict[pandas._typing.HashableT1,Union[numpy.datetime64,datetime.datetime,datetime.date]],numpy.datetime64,datetime.datetime,datetime.date]Z
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex
+Htyping.Sequence[Union[numpy.datetime64,datetime.datetime,datetime.date]]
+7Union[numpy.datetime64,datetime.datetime,datetime.date]$
+numpy.datetime64"numpy.datetime64&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date"typing.Sequence
+`builtins.dict[pandas._typing.HashableT1,Union[numpy.datetime64,datetime.datetime,datetime.date]]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable
+7Union[numpy.datetime64,datetime.datetime,datetime.date]$
+numpy.datetime64"numpy.datetime64&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date"
builtins.dict$
+numpy.datetime64"numpy.datetime64&
+datetime.datetime"datetime.datetime
+
datetime.date"
datetime.date*
 
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *&
+dtype&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-nunique!pandas.core.series.Series.nunique"
-builtins.int"builtins.int*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*,
-dropna
-
builtins.bool"
builtins.bool *V
-powpandas.core.series.Series.pow"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date
-
datetime.time"
datetime.time
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.float$
-builtins.complex"builtins.complex	
-TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
-Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadXt
+__new__!pandas.core.series.Series.__new__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -35061,19 +42450,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*"
-other"
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*.
+data.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -35084,16 +42468,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -35120,58 +42498,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *\
-
-fill_valueJ
-Union[builtins.float,None] 
-builtins.float"builtins.float
-None *
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *)
-prodpandas.core.series.Series.prod"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -35198,58 +42532,145 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLike*
+
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *&
+dtype&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *-
-	min_count
-builtins.int"builtins.int *
-kwargs
-Any*)
-product!pandas.core.series.Series.product"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg*.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadX#
+__new__!pandas.core.series.Series.__new__"B
+pandas.core.series.PeriodSeries"pandas.core.series.PeriodSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -35276,39 +42697,53 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *-
-	min_count
-builtins.int"builtins.int *
-kwargs
-Any*Z
-raddpandas.core.series.Series.radd"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+`Union[pandas.core.indexes.period.PeriodIndex,typing.Sequence[pandas._libs.tslibs.period.Period]]P
+&pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex
+2typing.Sequence[pandas._libs.tslibs.period.Period]F
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period"typing.Sequence*
+
+index
+
+Union[TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]],None]
+TypeAlias[Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]]
+Union[TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],builtins.list[Any],builtins.dict[Any,Any],builtins.range,builtins.tuple[Any]]
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLike,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict 
+builtins.range"builtins.range.
+builtins.tuple[Any]
+Any"builtins.tuple"pandas._typing.Axes
+None *[
+dtypeN
+%pandas.core.dtypes.dtypes.PeriodDtype"%pandas.core.dtypes.dtypes.PeriodDtype *.
+name"
+typing.Hashable"typing.Hashable **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadXL
+__new__!pandas.core.series.Series.__new__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+cls
+2Type[pandas.core.series.Series[pandas._typing.S1]]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -35335,18 +42770,162 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"type*
+data
+Union[pandas.core.indexes.timedeltas.TimedeltaIndex,typing.Sequence[Union[numpy.timedelta64,datetime.timedelta]],builtins.dict[pandas._typing.HashableT1,Union[numpy.timedelta64,datetime.timedelta]],numpy.timedelta64,datetime.timedelta]^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex
+
-sort_values%pandas.core.series.Series.sort_values"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42552,18 +49309,35 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+func
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+args
+Any*
+kwargs
+Any0:typing.overloadX
+	transform#pandas.core.series.Series.transform":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42590,67 +49364,45 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+func
+Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
+Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
+JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
+?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+CallableType[builtins.function]&
+builtins.function"builtins.function
+builtins.str"builtins.str
+numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
+YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
+Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.HashableV
+%Union[Unknown,builtins.list[Unknown]])
+builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame*
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX?
-sort_values%pandas.core.series.Series.sort_values"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+args
+Any*
+kwargs
+Any0:typing.overloadX2,
+applypandas.core.series.Series.apply
+applypandas.core.series.Series.apply"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42677,19 +49429,27 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*U
+funcK
+CallableType[builtins.function]&
+builtins.function"builtins.function*2
+convertDType
+
builtins.bool"
builtins.bool *:
+args.
+builtins.tuple[Any]
+Any"builtins.tuple *
+kwds
+Any0:typing.overloadX
+applypandas.core.series.Series.apply":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42716,72 +49476,28 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*U
+funcK
 CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2
-
-sort_index$pandas.core.series.Series.sort_index*
-
-sort_index$pandas.core.series.Series.sort_index"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.function"builtins.function*2
+convertDType
+
builtins.bool"
builtins.bool *:
+args.
+builtins.tuple[Any]
+Any"builtins.tuple *
+kwds
+Any0:typing.overloadX2
+rename pandas.core.series.Series.rename'
+rename pandas.core.series.Series.rename"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42808,15 +49524,27 @@ sort_index$pandas.core.series.Series.sort_index"
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+index
+Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer"
+typing.Hashable"typing.Hashable
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -42830,57 +49558,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*
 level
 :Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
 builtins.int"builtins.int"pandas._typing.Level
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
+None *
+errors
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX,
-
-sort_index$pandas.core.series.Series.sort_index"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX:
+rename pandas.core.series.Series.rename"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -42907,85 +49610,16 @@ sort_index$pandas.core.series.Series.sort_index"D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX-
-
-sort_index$pandas.core.series.Series.sort_index"~
-*Union[pandas.core.series.Series[Any],None]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43012,15 +49646,26 @@ sort_index$pandas.core.series.Series.sort_index"~
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+index
+xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
+CallableType[builtins.function]&
+builtins.function"builtins.function"pandas._typing.Renamer
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
 TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
 Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -43034,58 +49679,68 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-level
-rUnion[TypeAlias[Union[typing.Hashable,builtins.int]],builtins.list[builtins.int],builtins.list[builtins.str],None]
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
 .TypeAlias[Union[typing.Hashable,builtins.int]]i
 #Union[typing.Hashable,builtins.int]"
 typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.LevelJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.listJ
-builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-None *
-	ascending
-3Union[builtins.bool,typing.Sequence[builtins.bool]]
-
builtins.bool"
builtins.boolQ
-typing.Sequence[builtins.bool]
-
builtins.bool"
builtins.bool"typing.Sequence *V
-inplaceG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-kind
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.SortKind *
-na_position
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.NaPosition *4
-sort_remaining
-
builtins.bool"
builtins.bool *2
-ignore_index
-
builtins.bool"
builtins.bool *
-key
-+Union[CallableType[builtins.function],None]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-None 0:typing.overloadX2l
-	aggregate#pandas.core.series.Series.aggregate2
-	aggregate#pandas.core.series.Series.aggregate"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX6
+rename pandas.core.series.Series.rename"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43112,18 +49767,60 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*Z
+indexM
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX'
+rename pandas.core.series.Series.rename"~
+*Union[pandas.core.series.Series[Any],None]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43150,36 +49847,67 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+index
+Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
+lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
+aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
+:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
+Any
+&TypeAlias[Union[typing.Hashable,None]]M
+Union[typing.Hashable,None]"
+typing.Hashable"typing.Hashable
+None"pandas._typing.Label"typing.MappingK
 CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
+builtins.function"builtins.function"pandas._typing.Renamer"
+typing.Hashable"typing.Hashable
+None *
+axis
+Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX9
-	aggregate#pandas.core.series.Series.aggregate"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
+None **
+copy
+
builtins.bool"
builtins.bool *-
+inplace
+
builtins.bool"
builtins.bool *
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
+fillna pandas.core.series.Series.fillna>
+fillna pandas.core.series.Series.fillna"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43206,18 +49934,38 @@ JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+value%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43244,44 +49992,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-TypeAlias[Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]]
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-;TypeAlias[typing.Mapping[pandas._typing.HashableT,Unknown]]
-0typing.Mapping[pandas._typing.HashableT,Unknown]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.Hashable"typing.Mapping"$pandas._typing.AggFuncTypeDictSeries"'pandas._typing.AggFuncTypeSeriesToFrame *
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX2V
-	transform#pandas.core.series.Series.transform3
-	transform#pandas.core.series.Series.transform"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool0:typing.overloadXQ
+fillna pandas.core.series.Series.fillna"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43308,18 +50049,15 @@ JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43346,38 +50084,38 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+value%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX"
-	transform#pandas.core.series.Series.transform":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43404,48 +50142,38 @@ JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-func
-Union[builtins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]],TypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]]
-Ybuiltins.list[TypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]]
-JTypeAlias[Union[CallableType[builtins.function],builtins.str,numpy.ufunc]]
-?Union[CallableType[builtins.function],builtins.str,numpy.ufunc]K
-CallableType[builtins.function]&
-builtins.function"builtins.function
-builtins.str"builtins.str
-numpy.ufunc"numpy.ufunc"pandas._typing.AggFuncTypeBase"
builtins.list
-YTypeAlias[typing.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]]
-Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]Q
-pandas._typing.HashableT"
-typing.Hashable"typing.Hashable"typing.HashableV
-%Union[Unknown,builtins.list[Unknown]])
-builtins.list[Unknown]"
builtins.list"typing.Mapping"#pandas._typing.AggFuncTypeDictFrame*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-args
-Any*
-kwargs
-Any0:typing.overloadX23
-applypandas.core.series.Series.apply
-applypandas.core.series.Series.apply"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool 0:typing.overloadXQ
+fillna pandas.core.series.Series.fillna"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43472,30 +50200,16 @@ Ntyping.Mapping[pandas._typing.HashableT,Union[Unknown,builtins.list[Unknown]]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*2
-convertDType
-
builtins.bool"
builtins.bool *:
-args.
-builtins.tuple[Any]
-Any"builtins.tuple *
-kwds
-Any0:typing.overloadX
-applypandas.core.series.Series.apply":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43522,31 +50236,38 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*%
+value%
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*U
-funcK
-CallableType[builtins.function]&
-builtins.function"builtins.function*2
-convertDType
-
builtins.bool"
builtins.bool *:
-args.
-builtins.tuple[Any]
-Any"builtins.tuple *
-kwds
-Any0:typing.overloadX2
-rename pandas.core.series.Series.rename*
-rename pandas.core.series.Series.rename"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43573,71 +50294,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-index
-Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
-lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
-aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
-:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
-Any
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label"typing.MappingK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Renamer"
-typing.Hashable"typing.Hashable
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None *
+axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX*
-rename pandas.core.series.Series.rename"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *-
+inplace
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2
+replace!pandas.core.series.Series.replaceS
+replace!pandas.core.series.Series.replace"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43664,70 +50351,15 @@ aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[b
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-index
-xUnion[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],None]
-lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
-aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
-:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
-Any
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label"typing.MappingK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Renamer
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX%
-rename pandas.core.series.Series.rename"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43738,79 +50370,39 @@ aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[b
 builtins.complex"builtins.complex	
 TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
 Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
-Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
-builtins.str"builtins.strI
-numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtype:
-Type[builtins.str]
-builtins.str"builtins.str"typeF
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"typeC
-Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*Z
-indexM
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX+
-rename pandas.core.series.Series.rename"~
-*Union[pandas.core.series.Series[Any],None]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+to_replace
+~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
+builtins.str"builtins.str,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43837,70 +50429,65 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series 
+builtins.float"builtins.float
+None *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-index
-Union[TypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]],typing.Hashable,None]
-lTypeAlias[Union[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]]
-aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[builtins.function]]
-:typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]]
-Any
-&TypeAlias[Union[typing.Hashable,None]]M
-Union[typing.Hashable,None]"
-typing.Hashable"typing.Hashable
-None"pandas._typing.Label"typing.MappingK
-CallableType[builtins.function]&
-builtins.function"builtins.function"pandas._typing.Renamer"
-typing.Hashable"typing.Hashable
-None *
-axis
-Union[TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]],None]
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict,
+builtins.list[Any]
+Any"
builtins.list
+builtins.str"builtins.str
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis
-None **
-copy
-
builtins.bool"
builtins.bool *-
-inplace
-
builtins.bool"
builtins.bool *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
-droppandas.core.series.Series.drop+
-droppandas.core.series.Series.drop"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX@
+replace!pandas.core.series.Series.replace"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -43927,77 +50514,23 @@ aUnion[typing.Mapping[Any,TypeAlias[Union[typing.Hashable,None]]],CallableType[b
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT2],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT2]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-columns
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT3]R
-pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX,
-droppandas.core.series.Series.drop"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+to_replace
+~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
+builtins.str"builtins.str,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44024,79 +50557,64 @@ cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.inde
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series 
+builtins.float"builtins.float
+None *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
+TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
+
+Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
+TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
+Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedelta$
+numpy.datetime64"numpy.datetime64&
+numpy.timedelta64"numpy.timedelta64
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
 builtins.float"builtins.floatT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
+builtins.complex"builtins.complex"pandas._typing.Scalar:
+pandas._libs.missing.NAType"pandas._libs.missing.NAType9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict,
+builtins.list[Any]
+Any"
builtins.list
+builtins.str"builtins.str
+None *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT2],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT2]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-columns
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT3]R
-pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *I
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX,
-droppandas.core.series.Series.drop"~
-*Union[pandas.core.series.Series[Any],None]D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool0:typing.overloadXT
+replace!pandas.core.series.Series.replace"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44123,76 +50641,16 @@ cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.inde
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-labels
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT1],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT1]R
-pandas._typing.HashableT1"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-axis
-TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
-index
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT2],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT2]R
-pandas._typing.HashableT2"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-columns
-cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.indexes.base.Index[Any]]"
-typing.Hashable"typing.Hashable
-(builtins.list[pandas._typing.HashableT3]R
-pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.listN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index *
-level
-:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
-.TypeAlias[Union[typing.Hashable,builtins.int]]i
-#Union[typing.Hashable,builtins.int]"
-typing.Hashable"typing.Hashable
-builtins.int"builtins.int"pandas._typing.Level
-None *-
-inplace
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2
-fillna pandas.core.series.Series.fillnaI
-fillna pandas.core.series.Series.fillna"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44219,16 +50677,58 @@ cUnion[typing.Hashable,builtins.list[pandas._typing.HashableT3],pandas.core.inde
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+
+to_replace
+~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
+builtins.str"builtins.str,
+builtins.list[Any]
+Any"
builtins.list9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
-value)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series 
+builtins.float"builtins.float
+None *
+value
+Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
 
 Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
@@ -44250,10 +50750,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 pandas._libs.missing.NAType"pandas._libs.missing.NAType9
 builtins.dict[Any,Any]
 Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
builtins.dict,
+builtins.list[Any]
+Any"
builtins.list
+builtins.str"builtins.str
+None *-
+inplace
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+regex
+Any *
+method
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX2o
+dropna pandas.core.series.Series.dropna
+dropna pandas.core.series.Series.dropna"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44280,53 +50805,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None *
-method
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions
-None *
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None *G
+builtins.int"builtins.int"pandas._typing.AxisIndex *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX`
-fillna pandas.core.series.Series.fillna"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None 0:typing.overloadX+
+dropna pandas.core.series.Series.dropna"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44353,18 +50857,15 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44391,41 +50892,69 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
-value)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None 0:typing.overloadX+
+dropna pandas.core.series.Series.dropna"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
 
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44452,54 +50981,35 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None *
-method
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions
-None *
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadXa
-fillna pandas.core.series.Series.fillna"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex *-
+inplace
+
builtins.bool"
builtins.bool *
+how
+7Union[Literal[builtins.str],Literal[builtins.str],None]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+None 0:typing.overloadX2
+astype pandas.core.series.Series.astype 
+astype pandas.core.series.Series.astype"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44526,19 +51036,49 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"type7
+Literal[builtins.str]	
+builtins.str"builtins.strR
+'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Type[numpy.bool_]
+numpy.bool_"numpy.bool_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BooleanDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXs
+astype pandas.core.series.Series.astype"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44565,41 +51105,187 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*)
-value)
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*[
+dtype[
+Union[TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]]&
+TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.int]
+builtins.int"builtins.int"type7
+Literal[builtins.str]	
+builtins.str"builtins.strL
+$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
+%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
+%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
+%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+)Type[numpy.signedinteger[TypeAlias[Any]]]v
+#numpy.signedinteger[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strc
+"Type[numpy.signedinteger[Unknown]]5
+numpy.signedinteger[Unknown]"numpy.signedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IntDtypeArg$
+TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
+%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
+&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
+&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
+&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.stri
+$Type[numpy.unsignedinteger[Unknown]]9
+numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.UIntDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX 
+astype pandas.core.series.Series.astype"b
+'pandas.core.series.Series[builtins.str]
+builtins.str"builtins.str"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44626,20 +51312,25 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
-None *
-method
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*	
+dtype	
+TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
+Type[builtins.str]
+builtins.str"builtins.str"type7
+Literal[builtins.str]	
+builtins.str"builtins.strP
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str4
+Type[numpy.str_]
+
+numpy.str_"
+numpy.str_"type7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -44647,32 +51338,27 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FillnaOptions
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-inplace
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2
-replace!pandas.core.series.Series.replace^
-replace!pandas.core.series.Series.replace"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.StrDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+astype pandas.core.series.Series.astype"h
+)pandas.core.series.Series[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44699,18 +51385,46 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.bytes] 
+builtins.bytes"builtins.bytes"type7
+Literal[builtins.str]	
+builtins.str"builtins.str:
+Type[numpy.bytes_]
+numpy.bytes_"numpy.bytes_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.BytesDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX5
+astype pandas.core.series.Series.astype"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44737,26 +51451,98 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-to_replace
-~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
-builtins.str"builtins.str,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
+Type[builtins.float] 
+builtins.float"builtins.float"type7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
+(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str
+$Type[numpy.floating[TypeAlias[Any]]]l
+numpy.floating[TypeAlias[Any]]:
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitHalf"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.strT
+Type[numpy.floating[Unknown]]+
+numpy.floating[Unknown]"numpy.floating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.FloatDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX,
+astype pandas.core.series.Series.astype"n
++pandas.core.series.Series[builtins.complex]$
+builtins.complex"builtins.complex"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44783,68 +51569,75 @@ to_replace
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series 
-builtins.float"builtins.float
-None *
-value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list
-builtins.str"builtins.str
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-regex
-Any *
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type7
+Literal[builtins.str]	
+builtins.str"builtins.str
+3Type[numpy.complexfloating[TypeAlias[Any],Unknown]]
+-numpy.complexfloating[TypeAlias[Any],Unknown]<
+TypeAlias[Any]
+Any"numpy._typing._nbit._NBitSingle"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str{
+,Type[numpy.complexfloating[Unknown,Unknown]]C
+&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ComplexDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadXG
-replace!pandas.core.series.Series.replace"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX;
+astype pandas.core.series.Series.astype"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44871,26 +51664,121 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-
-to_replace
-~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
-builtins.str"builtins.str,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*$
+dtype$
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX=
+astype pandas.core.series.Series.astype"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -44917,67 +51805,126 @@ to_replace
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series 
-builtins.float"builtins.float
-None *
-value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list
-builtins.str"builtins.str
-None *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-regex
-Any *
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*&
+dtype&
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ReplaceMethod *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadX^
-replace!pandas.core.series.Series.replace"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.TimestampDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
+astype pandas.core.series.Series.astype"
+Epandas.core.series.Series[pandas.core.dtypes.dtypes.CategoricalDtype]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45004,19 +51951,33 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
+GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.CategoryDtypeArg**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX$
+astype pandas.core.series.Series.astype"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45043,26 +52004,57 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dtype
+Union[TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
+gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
+\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
+Type[builtins.object]"
+builtins.object"builtins.object"type7
+Literal[builtins.str]	
+builtins.str"builtins.str=
+Type[numpy.object_]
+
numpy.object_"
numpy.object_"type7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
+dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
+Type[numpy.void]
 
-to_replace
-~Union[builtins.str,builtins.list[Any],builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],builtins.float,None]
-builtins.str"builtins.str,
-builtins.list[Any]
-Any"
builtins.list9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+numpy.void"
+numpy.void"type7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.VoidDtypeArgP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
+HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtypeP
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj**
+copy
+
builtins.bool"
builtins.bool *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2E
+ffillpandas.core.series.Series.ffill
+ffillpandas.core.series.Series.ffill"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45089,68 +52081,37 @@ to_replace
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series 
-builtins.float"builtins.float
-None *
-value
-Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.missing.NAType,builtins.dict[Any,Any],builtins.list[Any],builtins.str,None]
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar:
-pandas._libs.missing.NAType"pandas._libs.missing.NAType9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list
-builtins.str"builtins.str
-None *-
-inplace
-
builtins.bool"
builtins.bool *Q
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *G
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool*Q
 limitD
 Union[builtins.int,None]
 builtins.int"builtins.int
-None *
-regex
-Any *
-method
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ReplaceMethod 0:typing.overloadX2
-dropna pandas.core.series.Series.dropna
-dropna pandas.core.series.Series.dropna"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX,
+ffillpandas.core.series.Series.ffill"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45177,35 +52138,15 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*
-how
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None 0:typing.overloadX2
-dropna pandas.core.series.Series.dropna"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45232,18 +52173,40 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2ř
+bfillpandas.core.series.Series.bfill
+bfillpandas.core.series.Series.bfill"
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45270,36 +52233,37 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *I
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *
-how
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None 0:typing.overloadX2
-dropna pandas.core.series.Series.dropna"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool*Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX,
+bfillpandas.core.series.Series.bfill"
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45323,22 +52287,18 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Type[builtins.bool]
 
builtins.bool"
builtins.bool"typeC
 Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45365,38 +52325,38 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-inplace
-
builtins.bool"
builtins.bool *
-how
-7Union[Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None 0:typing.overloadX2֔
-astype pandas.core.series.Series.astype$
-astype pandas.core.series.Series.astype"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *I
+inplace:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadXS
+bfillpandas.core.series.Series.bfill"
+8Union[pandas.core.series.Series[pandas._typing.S1],None]
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45423,54 +52383,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*	
-dtype	
-TypeAlias[Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.bool],Literal[builtins.str],pandas.core.arrays.boolean.BooleanDtype,Literal[builtins.str],Type[numpy.bool_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]=
-Type[builtins.bool]
-
builtins.bool"
builtins.bool"type7
-Literal[builtins.str]	
-builtins.str"builtins.strR
-'pandas.core.arrays.boolean.BooleanDtype"'pandas.core.arrays.boolean.BooleanDtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Type[numpy.bool_]
-numpy.bool_"numpy.bool_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.BooleanDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXx
-astype pandas.core.series.Series.astype"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45497,194 +52419,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*]
-dtype]
-Union[TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]]'
-TypeAlias[Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.int],Literal[builtins.str],pandas.core.arrays.integer.Int8Dtype,pandas.core.arrays.integer.Int16Dtype,pandas.core.arrays.integer.Int32Dtype,pandas.core.arrays.integer.Int64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.signedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
-Type[builtins.int]
-builtins.int"builtins.int"type7
-Literal[builtins.str]	
-builtins.str"builtins.strL
-$pandas.core.arrays.integer.Int8Dtype"$pandas.core.arrays.integer.Int8DtypeN
-%pandas.core.arrays.integer.Int16Dtype"%pandas.core.arrays.integer.Int16DtypeN
-%pandas.core.arrays.integer.Int32Dtype"%pandas.core.arrays.integer.Int32DtypeN
-%pandas.core.arrays.integer.Int64Dtype"%pandas.core.arrays.integer.Int64Dtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-)Type[numpy.signedinteger[TypeAlias[Any]]]v
-#numpy.signedinteger[TypeAlias[Any]]:
-TypeAlias[Any]
-Any"numpy._typing._nbit._NBitByte"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strc
-"Type[numpy.signedinteger[Unknown]]5
-numpy.signedinteger[Unknown]"numpy.signedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IntDtypeArg%
-TypeAlias[Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[pandas.core.arrays.integer.UInt8Dtype,pandas.core.arrays.integer.UInt16Dtype,pandas.core.arrays.integer.UInt32Dtype,pandas.core.arrays.integer.UInt64Dtype,Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Type[numpy.unsignedinteger[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]N
-%pandas.core.arrays.integer.UInt8Dtype"%pandas.core.arrays.integer.UInt8DtypeP
-&pandas.core.arrays.integer.UInt16Dtype"&pandas.core.arrays.integer.UInt16DtypeP
-&pandas.core.arrays.integer.UInt32Dtype"&pandas.core.arrays.integer.UInt32DtypeP
-&pandas.core.arrays.integer.UInt64Dtype"&pandas.core.arrays.integer.UInt64Dtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.stri
-$Type[numpy.unsignedinteger[Unknown]]9
-numpy.unsignedinteger[Unknown]"numpy.unsignedinteger"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.UIntDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX$
-astype pandas.core.series.Series.astype"b
-'pandas.core.series.Series[builtins.str]
-builtins.str"builtins.str"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*'
+value'
+xUnion[pandas._typing.S1,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45711,56 +52454,17 @@ $Type[numpy.unsignedinteger[Unknown]]9
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*	
-dtype	
-TypeAlias[Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.str],Literal[builtins.str],pandas.core.arrays.string_.StringDtype,Literal[builtins.str],Type[numpy.str_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]:
-Type[builtins.str]
-builtins.str"builtins.str"type7
-Literal[builtins.str]	
-builtins.str"builtins.strP
-&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype7
-Literal[builtins.str]	
-builtins.str"builtins.str4
-Type[numpy.str_]
-
-numpy.str_"
-numpy.str_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.StrDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX"
-astype pandas.core.series.Series.astype"h
-)pandas.core.series.Series[builtins.bytes] 
-builtins.bytes"builtins.bytes"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45787,51 +52491,39 @@ numpy.str_"type7
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-TypeAlias[Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.bytes],Literal[builtins.str],Type[numpy.bytes_],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
-Type[builtins.bytes] 
-builtins.bytes"builtins.bytes"type7
-Literal[builtins.str]	
-builtins.str"builtins.str:
-Type[numpy.bytes_]
-numpy.bytes_"numpy.bytes_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.BytesDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX9
-astype pandas.core.series.Series.astype"h
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *-
+inplace
+
builtins.bool"
builtins.bool *Q
+limitD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *{
+downcastk
+"Union[builtins.dict[Any,Any],None]9
+builtins.dict[Any,Any]
+Any
+Any"
builtins.dict
+None 0:typing.overloadX2.
+value_counts&pandas.core.series.Series.value_counts
+value_counts&pandas.core.series.Series.value_counts"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45858,101 +52550,31 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-TypeAlias[Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.float],Literal[builtins.str],pandas.core.arrays.floating.Float32Dtype,pandas.core.arrays.floating.Float64Dtype,Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[TypeAlias[Any]]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.floating[Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]@
-Type[builtins.float] 
-builtins.float"builtins.float"type7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-(pandas.core.arrays.floating.Float32Dtype"(pandas.core.arrays.floating.Float32DtypeT
-(pandas.core.arrays.floating.Float64Dtype"(pandas.core.arrays.floating.Float64Dtype7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-$Type[numpy.floating[TypeAlias[Any]]]l
-numpy.floating[TypeAlias[Any]]:
-TypeAlias[Any]
-Any"numpy._typing._nbit._NBitHalf"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-Type[numpy.floating[Unknown]]+
-numpy.floating[Unknown]"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-Type[numpy.floating[Unknown]]+
-numpy.floating[Unknown]"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.strT
-Type[numpy.floating[Unknown]]+
-numpy.floating[Unknown]"numpy.floating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.FloatDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX0
-astype pandas.core.series.Series.astype"n
-+pandas.core.series.Series[builtins.complex]$
-builtins.complex"builtins.complex"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*K
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *P
+binsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX
+value_counts&pandas.core.series.Series.value_counts"h
+)pandas.core.series.Series[builtins.float] 
+builtins.float"builtins.float"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -45979,78 +52601,30 @@ $Type[numpy.floating[TypeAlias[Any]]]l
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-TypeAlias[Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Type[builtins.complex],Literal[builtins.str],Type[numpy.complexfloating[TypeAlias[Any],Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Type[numpy.complexfloating[Unknown,Unknown]],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]F
-Type[builtins.complex]$
-builtins.complex"builtins.complex"type7
-Literal[builtins.str]	
-builtins.str"builtins.str
-3Type[numpy.complexfloating[TypeAlias[Any],Unknown]]
--numpy.complexfloating[TypeAlias[Any],Unknown]<
-TypeAlias[Any]
-Any"numpy._typing._nbit._NBitSingle"numpy.complexfloating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str{
-,Type[numpy.complexfloating[Unknown,Unknown]]C
-&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str{
-,Type[numpy.complexfloating[Unknown,Unknown]]C
-&numpy.complexfloating[Unknown,Unknown]"numpy.complexfloating"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ComplexDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX?
-astype pandas.core.series.Series.astype"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*I
+	normalize:
+Literal[builtins.bool]	
+
builtins.bool"
builtins.bool**
+sort
+
builtins.bool"
builtins.bool */
+	ascending
+
builtins.bool"
builtins.bool *P
+binsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+dropna
+
builtins.bool"
builtins.bool 0:typing.overloadX2ϗ
+__add__!pandas.core.series.Series.__add__O
+__add__!pandas.core.series.Series.__add__"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46077,124 +52651,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$
-dtype$
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.TimedeltaDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadXA
-astype pandas.core.series.Series.astype"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46221,129 +52686,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*&
-dtype&
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.TimestampDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX
-astype pandas.core.series.Series.astype"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*'&
+7Union[pandas._typing.S1,pandas.core.series.Series.Self]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46370,36 +52720,52 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-RTypeAlias[Union[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]]
-GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.CategoryDtypeArg**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX(
-astype pandas.core.series.Series.astype"D
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(0:typing.overloadXH
+__add__!pandas.core.series.Series.__add__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46426,60 +52792,66 @@ GUnion[pandas.core.dtypes.dtypes.CategoricalDtype,Literal[builtins.str]]X
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*33
+Union[builtins.complex,builtins.str,datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any],numpy.timedelta64]$
+builtins.complex"builtins.complex
+builtins.str"builtins.str(
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dtype
-Union[TypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]],TypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]]
-gTypeAlias[Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]]
-\Union[Type[builtins.object],Literal[builtins.str],Type[numpy.object_],Literal[builtins.str]]C
-Type[builtins.object]"
-builtins.object"builtins.object"type7
-Literal[builtins.str]	
-builtins.str"builtins.str=
-Type[numpy.object_]
-
numpy.object_"
numpy.object_"type7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.ObjectDtypeArg
-dTypeAlias[Union[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-YUnion[Type[numpy.void],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]4
-Type[numpy.void]
-
-numpy.void"
-numpy.void"type7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.VoidDtypeArgP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
-STypeAlias[Union[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]]
-HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
 numpy.dtype[numpy.generic]
-
numpy.generic"
numpy.generic"numpy.dtypeP
-&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype"pandas._typing.DtypeObj**
-copy
-
builtins.bool"
builtins.bool *
-errors
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.IgnoreRaise 0:typing.overloadX2P
-ffillpandas.core.series.Series.ffill
-ffillpandas.core.series.Series.ffill"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46506,40 +52878,21 @@ HUnion[numpy.dtype[numpy.generic],pandas.core.dtypes.base.ExtensionDtype]I
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX3
-ffillpandas.core.series.Series.ffill"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series&
+numpy.timedelta64"numpy.timedelta640:typing.overloadX28
+__and__!pandas.core.series.Series.__and__
+__and__!pandas.core.series.Series.__and__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46566,18 +52919,32 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
+
builtins.bool"
builtins.boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.listJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__and__!pandas.core.series.Series.__and__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46604,43 +52971,28 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2IJ
-bfillpandas.core.series.Series.bfill
-bfillpandas.core.series.Series.bfill"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2]
+__mul__!pandas.core.series.Series.__mul__
+__mul__!pandas.core.series.Series.__mul__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46667,40 +53019,22 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *G
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool*Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX3
-bfillpandas.core.series.Series.bfill"
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta640:typing.overloadXE
+__mul__!pandas.core.series.Series.__mul__"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46727,18 +53061,29 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46765,41 +53110,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *I
-inplace:
-Literal[builtins.bool]	
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadXb
-bfillpandas.core.series.Series.bfill"
-8Union[pandas.core.series.Series[pandas._typing.S1],None]
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46826,19 +53144,20 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__or__ pandas.core.series.Series.__or__
+__or__ pandas.core.series.Series.__or__"e
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46865,18 +53184,32 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*/
-value/
-xUnion[pandas._typing.S1,builtins.dict[Any,Any],pandas.core.series.Series[pandas._typing.S1],pandas.core.frame.DataFrame]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
+
builtins.bool"
builtins.boolM
+builtins.list[builtins.bool]
+
builtins.bool"
builtins.bool"
builtins.listJ
+builtins.list[builtins.int]
+builtins.int"builtins.int"
builtins.list
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__or__ pandas.core.series.Series.__or__"b
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46903,20 +53236,28 @@ xUnion[pandas._typing.S1,builtins.dict[Any,Any],pandas.core.series.Series[pandas
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
+builtins.int"builtins.int
+^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
+STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
+Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
+Any
+5numpy.dtype[numpy._typing._array_like._ScalarType_co][
+(numpy._typing._array_like._ScalarType_co
+
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
+'pandas.core.series.Series[builtins.int]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2
+__radd__"pandas.core.series.Series.__radd__N
+__radd__"pandas.core.series.Series.__radd__"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -46943,40 +53284,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *-
-inplace
-
builtins.bool"
builtins.bool *Q
-limitD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *{
-downcastk
-"Union[builtins.dict[Any,Any],None]9
-builtins.dict[Any,Any]
-Any
-Any"
builtins.dict
-None 0:typing.overloadX2φ
-__add__!pandas.core.series.Series.__add__
-__add__!pandas.core.series.Series.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47003,20 +53319,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*JH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadX
-__add__!pandas.core.series.Series.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*&&
+EUnion[pandas._typing.S1,pandas.core.series.Series[pandas._typing.S1]]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47043,20 +53353,14 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
-__add__!pandas.core.series.Series.__add__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47083,21 +53387,17 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*VT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:typing.overloadX<
-__add__!pandas.core.series.Series.__add__"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series0:typing.overloadXF
+__radd__"pandas.core.series.Series.__radd__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47124,20 +53424,16 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*$$
-Union[builtins.complex,builtins.str,pandas._libs.tslibs.timedeltas.Timedelta,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1],numpy.timedelta64]$
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,builtins.str,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
 builtins.complex"builtins.complex
-builtins.str"builtins.strT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+builtins.str"builtins.str.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -47148,16 +53444,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47184,22 +53474,54 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX2?
-__and__!pandas.core.series.Series.__and__ 
-__and__!pandas.core.series.Series.__and__"e
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__rand__"pandas.core.series.Series.__rand__
+__rand__"pandas.core.series.Series.__rand__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47226,14 +53548,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
 
builtins.bool"
builtins.boolM
 builtins.list[builtins.bool]
@@ -47248,13 +53567,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__and__!pandas.core.series.Series.__and__"b
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__rand__"pandas.core.series.Series.__rand__"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47281,14 +53600,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
 builtins.int"builtins.int
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -47299,13 +53615,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2>
-__mul__!pandas.core.series.Series.__mul__
-__mul__!pandas.core.series.Series.__mul__"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2]
+__rmul__"pandas.core.series.Series.__rmul__
+__rmul__"pandas.core.series.Series.__rmul__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47332,24 +53648,22 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64]T
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX$
-__mul__!pandas.core.series.Series.__mul__"D
+numpy.timedelta64"numpy.timedelta640:typing.overloadXE
+__rmul__"pandas.core.series.Series.__rmul__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47376,18 +53690,15 @@ dUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeri
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[Any]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -47398,22 +53709,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLikeD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series0:typing.overloadX2?
-__or__ pandas.core.series.Series.__or__ 
-__or__ pandas.core.series.Series.__or__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47440,35 +53739,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
-
builtins.bool"
builtins.boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.listJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__or__ pandas.core.series.Series.__or__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47492,35 +53770,23 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Type[builtins.bool]
 
builtins.bool"
builtins.bool"typeC
 Type[builtins.object]"
-builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2?
-__rand__"pandas.core.series.Series.__rand__ 
-__rand__"pandas.core.series.Series.__rand__"e
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__ror__!pandas.core.series.Series.__ror__
+__ror__!pandas.core.series.Series.__ror__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47547,14 +53813,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
 
builtins.bool"
builtins.boolM
 builtins.list[builtins.bool]
@@ -47569,13 +53832,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__rand__"pandas.core.series.Series.__rand__"b
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__ror__!pandas.core.series.Series.__ror__"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47602,14 +53865,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
 builtins.int"builtins.int
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -47620,14 +53880,14 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2?
-__ror__!pandas.core.series.Series.__ror__ 
-__ror__!pandas.core.series.Series.__ror__"e
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX28
+__rxor__"pandas.core.series.Series.__rxor__
+__rxor__"pandas.core.series.Series.__rxor__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47654,14 +53914,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
 
builtins.bool"
builtins.boolM
 builtins.list[builtins.bool]
@@ -47676,13 +53933,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__ror__!pandas.core.series.Series.__ror__"b
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__rxor__"pandas.core.series.Series.__rxor__"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47709,14 +53966,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
 builtins.int"builtins.int
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -47727,14 +53981,31 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2S
-__rtruediv__&pandas.core.series.Series.__rtruediv__
-__rtruediv__&pandas.core.series.Series.__rtruediv__"h
-)pandas.core.series.Series[builtins.float] 
-builtins.float"builtins.float"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2i
+__sub__!pandas.core.series.Series.__sub__
+__sub__!pandas.core.series.Series.__sub__"H
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
+Cpandas.core.series.Series[pandas._libs.tslibs.timestamps.Timestamp]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas.core.series.Series*
+Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
+__sub__!pandas.core.series.Series.__sub__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series*
+Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
+__sub__!pandas.core.series.Series.__sub__"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47761,21 +54032,21 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*JH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries0:typing.overloadX:
-__rtruediv__&pandas.core.series.Series.__rtruediv__"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.series.TimestampSeries]T
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp&
+datetime.datetime"datetime.datetimeH
+"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadXE
+__sub__!pandas.core.series.Series.__sub__"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47802,18 +54073,15 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*""
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[pandas._typing.S1]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*11
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -47824,16 +54092,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLike
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47860,21 +54122,54 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series0:typing.overloadX2?
-__rxor__"pandas.core.series.Series.__rxor__ 
-__rxor__"pandas.core.series.Series.__rxor__"e
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series0:typing.overloadX28
+__xor__!pandas.core.series.Series.__xor__
+__xor__!pandas.core.series.Series.__xor__"e
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47901,14 +54196,11 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
 
builtins.bool"
builtins.boolM
 builtins.list[builtins.bool]
@@ -47923,13 +54215,13 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
 (pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__rxor__"pandas.core.series.Series.__rxor__"b
+
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
+__xor__!pandas.core.series.Series.__xor__"b
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series*
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -47956,14 +54248,11 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
 builtins.int"builtins.int
 ^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
@@ -47974,31 +54263,14 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 (numpy._typing._array_like._ScalarType_co
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
 'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2K
-__sub__!pandas.core.series.Series.__sub__
-__sub__!pandas.core.series.Series.__sub__"H
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
-Cpandas.core.series.Series[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"pandas.core.series.Series*
-Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
-__sub__!pandas.core.series.Series.__sub__"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series*
-Union[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,pandas.core.indexes.timedeltas.TimedeltaIndex,numpy.timedelta64]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
-__sub__!pandas.core.series.Series.__sub__"H
-"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2i
+mulpandas.core.series.Series.mul
+mulpandas.core.series.Series.mul"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48025,24 +54297,45 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.series.TimestampSeries]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp&
-datetime.datetime"datetime.datetimeH
-"pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries0:typing.overloadX$
-__sub__!pandas.core.series.Series.__sub__"D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta64*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None 0:typing.overloadXK
+mulpandas.core.series.Series.mul"D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48069,18 +54362,16 @@ dUnion[pandas._libs.tslibs.timestamps.Timestamp,datetime.datetime,pandas.core.se
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]],pandas.core.series.Series[Any]]$
-builtins.complex"builtins.complex
-TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]]
-Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],builtins.list[Any],builtins.tuple[Any],pandas.core.indexes.base.Index[Any]]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*1
+other1
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
 OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
 DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
@@ -48091,22 +54382,10 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"
builtins.dict,
-builtins.list[Any]
-Any"
builtins.list.
-builtins.tuple[Any]
-Any"builtins.tupleN
-#pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index"#pandas.core.series.Series._ListLikeD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series0:typing.overloadX2?
-__xor__!pandas.core.series.Series.__xor__ 
-__xor__!pandas.core.series.Series.__xor__"e
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48133,35 +54412,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.bool,builtins.list[builtins.bool],builtins.list[builtins.int],TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.bool]]
-
builtins.bool"
builtins.boolM
-builtins.list[builtins.bool]
-
builtins.bool"
builtins.bool"
builtins.listJ
-builtins.list[builtins.int]
-builtins.int"builtins.int"
builtins.list
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray"pandas._typing.np_ndarray_boole
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series0:typing.overloadX
-__xor__!pandas.core.series.Series.__xor__"b
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series*
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48188,34 +54446,41 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-Union[builtins.int,TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]],pandas.core.series.Series[builtins.int]]
-builtins.int"builtins.int
-^TypeAlias[TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]]
-STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
-Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
-Any
-5numpy.dtype[numpy._typing._array_like._ScalarType_co][
-(numpy._typing._array_like._ScalarType_co
-
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArray" pandas._typing.np_ndarray_anyintb
-'pandas.core.series.Series[builtins.int]
-builtins.int"builtins.int"pandas.core.series.Series0:typing.overloadX2P
-rolling!pandas.core.series.Series.rolling'
-rolling!pandas.core.series.Series.rolling"
-Apandas.core.window.rolling.Window[pandas.core.series.Series[Any]]D
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series"!pandas.core.window.rolling.Window*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None 0:typing.overloadX2g
+rmulpandas.core.series.Series.rmul
+rmulpandas.core.series.Series.rmul"H
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48242,30 +54507,28 @@ Apandas.core.window.rolling.Window[pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
-window
-{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
-builtins.int"builtins.int
-builtins.str"builtins.str(
-datetime.timedelta"datetime.timedeltaP
-&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
- pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
-min_periodsD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *,
-center
-
builtins.bool"
builtins.bool *N
-onD
-Union[builtins.str,None]
-builtins.str"builtins.str
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+other
+wUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.series.TimedeltaSeries,numpy.timedelta64](
+datetime.timedelta"datetime.timedeltaT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltaH
+"pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries&
+numpy.timedelta64"numpy.timedelta64*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
 None *
 axis
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -48273,41 +54536,159 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
-closed
-uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
-iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType
-None *P
-stepD
-Union[builtins.int,None]
-builtins.int"builtins.int
-None *
-method
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
+builtins.int"builtins.int"pandas._typing.AxisIndex 0:typing.overloadXJ
+rmulpandas.core.series.Series.rmul"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*1
+other1
+Union[builtins.complex,TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],pandas.core.series.Series[Any]]$
+builtins.complex"builtins.complex.
+TypeAlias[Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]],
+Union[TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],builtins.dict[builtins.str,numpy.ndarray[Any,Any]],typing.Sequence[pandas._typing.S1],pandas.core.base.IndexOpsMixin[pandas._typing.S1]]
+OTypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]]
+DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.ArrayLike
+2builtins.dict[builtins.str,numpy.ndarray[Any,Any]]
+builtins.str"builtins.str9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"
builtins.dict
+"typing.Sequence[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"typing.Sequence
+1pandas.core.base.IndexOpsMixin[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
+builtins.int"builtins.int 
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.base.IndexOpsMixin"pandas.core.series._ListLikeD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+level
+:Union[TypeAlias[Union[typing.Hashable,builtins.int]],None]
+.TypeAlias[Union[typing.Hashable,builtins.int]]i
+#Union[typing.Hashable,builtins.int]"
+typing.Hashable"typing.Hashable
+builtins.int"builtins.int"pandas._typing.Level
+None *\
+
+fill_valueJ
+Union[builtins.float,None] 
+builtins.float"builtins.float
+None *
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod **
-win_type
-builtins.str"builtins.str0:typing.overloadX'
-rolling!pandas.core.series.Series.rolling"
-Bpandas.core.window.rolling.Rolling[pandas.core.series.Series[Any]]D
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex 0:typing.overloadX2D
+rolling!pandas.core.series.Series.rolling"
+rolling!pandas.core.series.Series.rolling"
+Apandas.core.window.rolling.Window[pandas.core.series.Series[Any]]D
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series""pandas.core.window.rolling.Rolling*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+Any"pandas.core.series.Series"!pandas.core.window.rolling.Window*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48334,14 +54715,11 @@ Bpandas.core.window.rolling.Rolling[pandas.core.series.Series[Any]]D
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 window
 {Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
 builtins.int"builtins.int
@@ -48358,14 +54736,7 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 onD
 Union[builtins.str,None]
 builtins.str"builtins.str
-None *
-axis
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
+None *
 closed
 uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
 iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
@@ -48389,66 +54760,17 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.CalculationMethod *
-win_type
-None 0:typing.overloadX2>
-sumpandas.core.series.Series.sum
-sumpandas.core.series.Series.sum"
-Any*X
-selfN
-#pandas.core.series.Series[NoReturn]
-NoReturn
-"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *-
-	min_count
-builtins.int"builtins.int *
-kwargs
-Any0:typing.overloadX
-sumpandas.core.series.Series.sum"
-builtins.int"builtins.int*o
-selfe
-(pandas.core.series.Series[builtins.bool]
-
builtins.bool"
builtins.bool"pandas.core.series.Series*
-axis
-IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
-2Union[Literal[builtins.str],Literal[builtins.int]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex
-None *U
-skipnaG
-Union[builtins.bool,None]
-
builtins.bool"
builtins.bool
-None *
-level
-None *2
-numeric_only
-
builtins.bool"
builtins.bool *-
-	min_count
-builtins.int"builtins.int *
-kwargs
-Any0:typing.overloadX2
-sumpandas.core.series.Series.sum"
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+builtins.str"builtins.str" pandas._typing.CalculationMethod **
+win_type
+builtins.str"builtins.str0:typing.overloadX"
+rolling!pandas.core.series.Series.rolling"
+Bpandas.core.window.rolling.Rolling[pandas.core.series.Series[Any]]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series""pandas.core.window.rolling.Rolling*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48475,18 +54797,111 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
+window
+{Union[builtins.int,builtins.str,datetime.timedelta,pandas._libs.tslibs.offsets.BaseOffset,pandas.core.indexers.BaseIndexer]
+builtins.int"builtins.int
+builtins.str"builtins.str(
+datetime.timedelta"datetime.timedeltaP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffsetD
+ pandas.core.indexers.BaseIndexer" pandas.core.indexers.BaseIndexer*W
+min_periodsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *,
+center
+
builtins.bool"
builtins.bool *N
+onD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *
+closed
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType
+None *P
+stepD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+method
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str" pandas._typing.CalculationMethod *
+win_type
+None 0:typing.overloadX27
+sumpandas.core.series.Series.sum
+sumpandas.core.series.Series.sum"
+Any*X
+selfN
+#pandas.core.series.Series[NoReturn]
+NoReturn
+"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *-
+	min_count
+builtins.int"builtins.int *
+kwargs
+Any0:typing.overloadX
+sumpandas.core.series.Series.sum"
+builtins.int"builtins.int*o
+selfe
+(pandas.core.series.Series[builtins.bool]
+
builtins.bool"
builtins.bool"pandas.core.series.Series*
+axis
+IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+None *U
+skipnaG
+Union[builtins.bool,None]
+
builtins.bool"
builtins.bool
+None *
+level
+None *2
+numeric_only
+
builtins.bool"
builtins.bool *-
+	min_count
+builtins.int"builtins.int *
+kwargs
+Any0:typing.overloadX+
+sumpandas.core.series.Series.sum"
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48513,14 +54928,46 @@ tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pand
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 axis
 IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
@@ -48541,14 +54988,14 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 	min_count
 builtins.int"builtins.int *
 kwargs
-Any0:typing.overloadX2΢
-rename_axis%pandas.core.series.Series.rename_axisP
+Any0:typing.overloadX2
+rename_axis%pandas.core.series.Series.rename_axisM
 rename_axis%pandas.core.series.Series.rename_axis"
-None*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+None*
+self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48575,14 +55022,11 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series*
 mapper
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._typing.ListLike]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -48674,14 +55118,12 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 
builtins.bool"
builtins.bool *G
 inplace:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool0:typing.overloadXQ
-rename_axis%pandas.core.series.Series.rename_axis"D
-pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-self
-,pandas.core.series.Series[pandas._typing.S1]
-pandas._typing.S1
-Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],pandas.core.dtypes.dtypes.CategoricalDtype]
+
builtins.bool"
builtins.bool0:typing.overloadXa
+rename_axis%pandas.core.series.Series.rename_axis"
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.str 
 builtins.bytes"builtins.bytes
 
datetime.date"
datetime.date
@@ -48708,14 +55150,47 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
 datetime.datetime"datetime.datetime(
 datetime.timedelta"datetime.timedeltaF
-!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.Period
-pandas._libs.interval.Interval[Union[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-tUnion[builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
+self
+pandas.core.series.Series.Self
+,pandas.core.series.Series[pandas._typing.S1]
+pandas._typing.S1
+Union[builtins.str,builtins.bytes,datetime.date,datetime.time,builtins.bool,builtins.int,builtins.float,builtins.complex,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],datetime.datetime,datetime.timedelta,pandas._libs.tslibs.period.Period,pandas._libs.interval.Interval[Any],pandas.core.dtypes.dtypes.CategoricalDtype,pandas._libs.tslibs.offsets.BaseOffset]
+builtins.str"builtins.str 
+builtins.bytes"builtins.bytes
+
datetime.date"
datetime.date
+
datetime.time"
datetime.time
+
builtins.bool"
builtins.bool
 builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._libs.interval.IntervalX
-*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtype"pandas.core.series.Series*
+builtins.float"builtins.float$
+builtins.complex"builtins.complex	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype&
+datetime.datetime"datetime.datetime(
+datetime.timedelta"datetime.timedeltaF
+!pandas._libs.tslibs.period.Period"!pandas._libs.tslibs.period.PeriodN
+#pandas._libs.interval.Interval[Any]
+Any"pandas._libs.interval.IntervalX
+*pandas.core.dtypes.dtypes.CategoricalDtype"*pandas.core.dtypes.dtypes.CategoricalDtypeP
+&pandas._libs.tslibs.offsets.BaseOffset"&pandas._libs.tslibs.offsets.BaseOffset"pandas.core.series.Series"pandas.core.series.Series(*
 mapper
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._typing.ListLike]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -48830,8 +55305,8 @@ IUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],None]
 na_value/pandas.core.arrays.string_.StringDtype.na_value":
 pandas._libs.missing.NAType"pandas._libs.missing.NAType*Z
 selfP
-&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype0:builtins.property`
-	Timedelta(pandas._libs.tslibs.timedeltas.Timedelta"datetime.timedelta*5
+&pandas.core.arrays.string_.StringDtype"&pandas.core.arrays.string_.StringDtype0:builtins.property`
+	Timedelta(pandas._libs.tslibs.timedeltas.Timedelta"datetime.timedelta*-
 __new__0pandas._libs.tslibs.timedeltas.Timedelta.__new__"
 -pandas._libs.tslibs.timedeltas.Timedelta.SelfT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
@@ -48845,30 +55320,10 @@ nUnion[builtins.str,builtins.int,pandas._libs.tslibs.timedeltas.Timedelta,dateti
 builtins.int"builtins.intT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(
 datetime.timedelta"datetime.timedelta&
-numpy.timedelta64"numpy.timedelta64 *#
-unit#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+numpy.timedelta64"numpy.timedelta64 *
+unit
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -49126,7 +55581,39 @@ aUnion[Tuple[TypeAlias[Any],builtins.int],Unknown,builtins.list[Any],TypeAlias[T
 builtins.list[Any]
 Any"
builtins.listM
 TypeAlias[TypedDict]
-	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike 2+
+	TypedDict"$numpy._typing._dtype_like._DTypeDict"(numpy._typing._dtype_like._VoidDTypeLike"#numpy._typing._dtype_like.DTypeLike *
+unit-pandas._libs.tslibs.timedeltas.Timedelta.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*^
+selfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta0:builtins.property`*
+as_unit0pandas._libs.tslibs.timedeltas.Timedelta.as_unit"
+-pandas._libs.tslibs.timedeltas.Timedelta.SelfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
+self
+-pandas._libs.tslibs.timedeltas.Timedelta.SelfT
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool 2+
 __add__0pandas._libs.tslibs.timedeltas.Timedelta.__add__
 __add__0pandas._libs.tslibs.timedeltas.Timedelta.__add__"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*VT
@@ -49290,7 +55777,7 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 mUnion[pandas.core.series.TimedeltaSeries,pandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]]H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries
 Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series0:typing.overloadX2$
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas.core.series.Series0:typing.overloadX2$
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*VT
@@ -49298,11 +55785,12 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 TUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedelta64](
 datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta&
-numpy.timedelta64"numpy.timedelta640:typing.overloadX
+numpy.timedelta64"numpy.timedelta640:typing.overloadX
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"T
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*VT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
-@Union[pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64]T
+(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
+RUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,numpy.datetime64]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp$
 numpy.datetime64"numpy.datetime640:typing.overloadX
 __rsub__1pandas._libs.tslibs.timedeltas.Timedelta.__rsub__"J
@@ -49829,8 +56317,8 @@ Cpandas.core.series.Series[pandas._libs.tslibs.timedeltas.Timedelta]T
 resolution3pandas._libs.tslibs.timedeltas.Timedelta.resolutionT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.TimedeltarU
 value.pandas._libs.tslibs.timedeltas.Timedelta.value
-builtins.int"builtins.intA
-TimedeltaIndex-pandas.core.indexes.timedeltas.TimedeltaIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"6pandas.core.indexes.accessors.TimedeltaIndexProperties*
+builtins.int"builtins.intT
+TimedeltaIndex-pandas.core.indexes.timedeltas.TimedeltaIndex"7pandas.core.indexes.datetimelike.DatetimeTimedeltaMixin"6pandas.core.indexes.accessors.TimedeltaIndexProperties*
 __new__5pandas.core.indexes.timedeltas.TimedeltaIndex.__new__"
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
@@ -49856,23 +56344,7 @@ cUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedel
 datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta&
 numpy.timedelta64"numpy.timedelta64 
-builtins.float"builtins.float"typing.Sequence *
-unit
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str *
+builtins.float"builtins.float"typing.Sequence *
 freq
 :Union[builtins.str,pandas._libs.tslibs.offsets.BaseOffset]
 builtins.str"builtins.strP
@@ -49885,19 +56357,21 @@ cUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,numpy.timedel
 copy
 
builtins.bool"
builtins.bool *(
 name
-builtins.str"builtins.str *
+builtins.str"builtins.str *
 __radd__6pandas.core.indexes.timedeltas.TimedeltaIndex.__radd__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*`^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-[Union[pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]T
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+mUnion[datetime.datetime,pandas._libs.tslibs.timestamps.Timestamp,pandas.core.indexes.datetimes.DatetimeIndex]&
+datetime.datetime"datetime.datetimeT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampZ
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
 __sub__5pandas.core.indexes.timedeltas.TimedeltaIndex.__sub__"
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
-bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self]T
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+uUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
@@ -49906,13 +56380,23 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*&$
-builtins.complex"builtins.complex*
-__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__"
-2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
-2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*&$
-builtins.complex"builtins.complex*
+builtins.complex"builtins.complex*
+__rtruediv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__rtruediv__"r
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence*
+
__rfloordiv__;pandas.core.indexes.timedeltas.TimedeltaIndex.__rfloordiv__"l
+,pandas.core.indexes.base.Index[builtins.int]
+builtins.int"builtins.int"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence*
 astype4pandas.core.indexes.timedeltas.TimedeltaIndex.astype"
 Any*h
 self^
@@ -49920,16 +56404,7 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 dtype
 Any**
 copy
-
builtins.bool"
builtins.bool *c
-	get_value7pandas.core.indexes.timedeltas.TimedeltaIndex.get_value*
-self*
-
-series*
-key*d
-get_loc5pandas.core.indexes.timedeltas.TimedeltaIndex.get_loc*
-self*
-key*
-	tolerance *
+
builtins.bool"
builtins.bool *
 searchsorted:pandas.core.indexes.timedeltas.TimedeltaIndex.searchsorted"
 Any*h
 self^
@@ -49955,7 +56430,7 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 index
 Any *
 name
-Any 2
+Any 2
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__"P
 &pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*`^
@@ -49964,16 +56439,55 @@ bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.T
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*`^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*\Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex0:typing.overloadX
 __add__5pandas.core.indexes.timedeltas.TimedeltaIndex.__add__"
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
 -pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
-bUnion[pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self]T
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+uUnion[datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,pandas.core.indexes.timedeltas.TimedeltaIndex.Self](
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
 2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(0:typing.overloadXю
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(0:typing.overloadX2
+
+__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__
+__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__"
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+7Union[builtins.complex,typing.Sequence[builtins.float]]$
+builtins.complex"builtins.complexT
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence0:typing.overloadX
+__truediv__9pandas.core.indexes.timedeltas.TimedeltaIndex.__truediv__"r
+.pandas.core.indexes.base.Index[builtins.float] 
+builtins.float"builtins.float"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence0:typing.overloadX2
+
+__floordiv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__floordiv__
+__floordiv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__floordiv__"
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+2pandas.core.indexes.timedeltas.TimedeltaIndex.Self^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex(*
+7Union[builtins.complex,typing.Sequence[builtins.float]]$
+builtins.complex"builtins.complexT
+typing.Sequence[builtins.float] 
+builtins.float"builtins.float"typing.Sequence0:typing.overloadX
+__floordiv__:pandas.core.indexes.timedeltas.TimedeltaIndex.__floordiv__"l
+,pandas.core.indexes.base.Index[builtins.int]
+builtins.int"builtins.int"pandas.core.indexes.base.Index*`^
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+=Union[datetime.timedelta,typing.Sequence[datetime.timedelta]](
+datetime.timedelta"datetime.timedelta`
+#typing.Sequence[datetime.timedelta](
+datetime.timedelta"datetime.timedelta"typing.Sequence0:typing.overloadX
 	Timestamp(pandas._libs.tslibs.timestamps.Timestamp"datetime.datetime*
 __new__0pandas._libs.tslibs.timestamps.Timestamp.__new__"
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
@@ -50170,12 +56684,14 @@ nanosecond3pandas._libs.tslibs.timestamps.Timestamp.nanosecond"
 cls
 3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
 -pandas._libs.tslibs.timestamps.Timestamp.SelfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
-combine0pandas._libs.tslibs.timestamps.Timestamp.combine"&
-datetime.datetime"datetime.datetime*
-cls
-.Type[pandas._libs.tslibs.timestamps.Timestamp]T
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"type*(
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type0:builtins.classmethodp*
+combine0pandas._libs.tslibs.timestamps.Timestamp.combine"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+cls
+3Type[pandas._libs.tslibs.timestamps.Timestamp.Self]
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp("type*(
 date
 
datetime.date"
datetime.date*(
 time
@@ -50358,13 +56874,9 @@ astimezone3pandas._libs.tslibs.timestamps.Timestamp.astimezone"
 isoweekday3pandas._libs.tslibs.timestamps.Timestamp.isoweekday"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
-isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
-8TypeAlias[Tuple[builtins.int,builtins.int,builtins.int]]
--Tuple[builtins.int,builtins.int,builtins.int]
-builtins.int"builtins.int
-builtins.int"builtins.int
-builtins.int"builtins.int"/pandas._libs.tslibs.timestamps._IsoCalendarDate*^
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
+isocalendar4pandas._libs.tslibs.timestamps.Timestamp.isocalendar"
+Any*^
 selfT
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
 is_leap_year5pandas._libs.tslibs.timestamps.Timestamp.is_leap_year"
@@ -50618,7 +57130,39 @@ weekofyear3pandas._libs.tslibs.timestamps.Timestamp.weekofyear"
 daysinmonth4pandas._libs.tslibs.timestamps.Timestamp.daysinmonth"
 builtins.int"builtins.int*^
 selfT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`2
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+unit-pandas._libs.tslibs.timestamps.Timestamp.unit"
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*^
+selfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp0:builtins.property`*
+as_unit0pandas._libs.tslibs.timestamps.Timestamp.as_unit"
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+self
+-pandas._libs.tslibs.timestamps.Timestamp.SelfT
+(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp(*
+unit
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.TimeUnit*.
+round_ok
+
builtins.bool"
builtins.bool 2
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__
 __le__/pandas._libs.tslibs.timestamps.Timestamp.__le__"
 
builtins.bool"
builtins.bool*VT
@@ -51037,7 +57581,7 @@ $pandas._config.config.option_context"$pandas._config.config.option_context*
 __exit__-pandas._config.config.option_context.__exit__"
 None*NL
 $pandas._config.config.option_context"$pandas._config.config.option_context*&"
-builtins.object"builtins.object
+builtins.object"builtins.object
 	ExcelFilepandas.io.excel._base.ExcelFile"builtins.object*
 
 __init__(pandas.io.excel._base.ExcelFile.__init__"
@@ -51114,8 +57658,8 @@ $pandas.io.excel._base.ExcelFile.SelfB
 None*
 __del__'pandas.io.excel._base.ExcelFile.__del__"
 None*DB
-pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile2d
-parse%pandas.io.excel._base.ExcelFile.parse3
+pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile2e
+parse%pandas.io.excel._base.ExcelFile.parse3
 parse%pandas.io.excel._base.ExcelFile.parse"
 Kbuiltins.dict[Union[builtins.int,builtins.str],pandas.core.frame.DataFrame]`
  Union[builtins.int,builtins.str]
@@ -51158,27 +57702,24 @@ sheet_name
 builtins.int"builtins.intN
 typing.Sequence[builtins.int]
 builtins.int"builtins.int"typing.Sequence
-None *
-
-usecols
-
-Union[builtins.str,TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]]
-builtins.str"builtins.str
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -51263,7 +57804,7 @@ skipfooter
 	na_filter
 
builtins.bool"
builtins.bool *
 kwds
-Any0:typing.overloadX0
+Any0:typing.overloadX1
 parse%pandas.io.excel._base.ExcelFile.parse":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*L
 selfB
@@ -51299,27 +57840,24 @@ sheet_name`
 builtins.int"builtins.intN
 typing.Sequence[builtins.int]
 builtins.int"builtins.int"typing.Sequence
-None *
-
-usecols
-
-Union[builtins.str,TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]]
-builtins.str"builtins.str
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -51416,8 +57954,8 @@ xUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.R
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
 )pandas._typing.ReadBuffer[builtins.bytes] 
 builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer 
-builtins.bytes"builtins.bytes*
-ExcelWriter!pandas.io.excel._base.ExcelWriter"builtins.object*
+builtins.bytes"builtins.bytes-
+ExcelWriter!pandas.io.excel._base.ExcelWriter"builtins.object*
 __init__*pandas.io.excel._base.ExcelWriter.__init__"
 None*P
 selfF
@@ -51430,15 +57968,17 @@ xUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.R
 os.PathLike[builtins.str]
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathB
 pandas._typing.WriteExcelBuffer"pandas._typing.WriteExcelBufferF
-!pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter*
-engine
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+!pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter*
+engine
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],Literal[builtins.str],None]
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str7
+builtins.str"builtins.str"pandas._typing.ExcelWriteEngine7
 Literal[builtins.str]	
 builtins.str"builtins.str
 None *W
@@ -51484,15 +58024,16 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 builtins.tuple[builtins.str]
 builtins.str"builtins.str"builtins.tuple*P
 selfF
-!pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter0:builtins.property`*
-engine(pandas.io.excel._base.ExcelWriter.engine"
+!pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter0:builtins.property`*
+engine(pandas.io.excel._base.ExcelWriter.engine"
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
 HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str*P
+builtins.str"builtins.str"pandas._typing.ExcelWriteEngine*P
 selfF
 !pandas.io.excel._base.ExcelWriter"!pandas.io.excel._base.ExcelWriter0:builtins.property`*
 sheets(pandas.io.excel._base.ExcelWriter.sheets"W
@@ -52023,7 +58564,7 @@ PUnion[builtins.str,numpy.dtype[Any],pandas.core.dtypes.base.ExtensionDtype,None
 &pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
 None **
 copy
-
builtins.bool"
builtins.bool 
+
builtins.bool"
builtins.bool 
 
 date_range(pandas.core.indexes.datetimes.date_range"Z
 +pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
@@ -52081,9 +58622,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType *
-unit
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType *
+unit
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -52091,7 +58634,7 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
+builtins.str"builtins.str"pandas._typing.TimeUnit
 None 
 
 period_range'pandas.core.indexes.period.period_range"P
@@ -52406,7 +58949,7 @@ value_name"
 builtins.str"builtins.str
 None *2
 ignore_index
-
builtins.bool"
builtins.bool /
+
builtins.bool"
builtins.bool .
 mergepandas.core.reshape.merge.merge":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 left
@@ -52512,9 +59055,7 @@ left_index
 builtins.str"builtins.strD
 Tuple[builtins.str,None]
 builtins.str"builtins.str
-None **
-copy
-
builtins.bool"
builtins.bool *t
+None *t
 	indicatorc
 !Union[builtins.bool,builtins.str]
 
builtins.bool"
builtins.bool
@@ -52537,7 +59078,7 @@ left_index
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.ValidationOptions 
+builtins.str"builtins.str" pandas._typing.ValidationOptions 
 
 merge_asof$pandas.core.reshape.merge.merge_asof":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
@@ -52621,10 +59162,11 @@ ZUnion[TypeAlias[Union[typing.Hashable,None]],builtins.list[pandas._typing.Hasha
 builtins.str"builtins.strD
 Tuple[builtins.str,None]
 builtins.str"builtins.str
-None *
-	tolerance
-AUnion[builtins.int,pandas._libs.tslibs.timedeltas.Timedelta,None]
-builtins.int"builtins.intT
+None *
+	tolerance
+TUnion[builtins.int,datetime.timedelta,pandas._libs.tslibs.timedeltas.Timedelta,None]
+builtins.int"builtins.int(
+datetime.timedelta"datetime.timedeltaT
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta
 None *9
 allow_exact_matches
@@ -52837,7 +59379,7 @@ MUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str
-None +
+None 0
 	read_htmlpandas.io.html.read_html"w
 *builtins.list[pandas.core.frame.DataFrame]:
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.list*
@@ -52855,10 +59397,18 @@ gUnion[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.R
 builtins.str"builtins.str&
 re.Pattern[Any]
 Any"
-re.Pattern *R
-flavorD
-Union[builtins.str,None]
-builtins.str"builtins.str
+re.Pattern *
+flavor
+xUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],typing.Sequence[Unknown],None]
+STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.HTMLFlavors-
+typing.Sequence[Unknown]"typing.Sequence
 None *
 header
 6Union[builtins.int,typing.Sequence[builtins.int],None]
@@ -52967,7 +59517,14 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions 
 read_orcpandas.io.orc.read_orc":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 path
@@ -53483,8 +60040,8 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType 0:typing.overloadX"
-	factorize pandas.core.algorithms.factorize
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType 0:typing.overloadX"
+	factorize pandas.core.algorithms.factorize
 	factorize pandas.core.algorithms.factorize"
 4Tuple[numpy.ndarray[Any,Any],numpy.ndarray[Any,Any]]9
 numpy.ndarray[Any,Any]
@@ -53492,14 +60049,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Any"
numpy.ndarray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-values
-3Union[typing.Sequence[Any],numpy.recarray[Any,Any]]0
-typing.Sequence[Any]
-Any"typing.Sequence;
-numpy.recarray[Any,Any]
+Any"
numpy.ndarray*E
+values9
+numpy.ndarray[Any,Any]
 Any
-Any"numpy.recarray**
+Any"
numpy.ndarray**
 sort
 
builtins.bool"
builtins.bool *5
 use_na_sentinel
@@ -53943,7 +60497,7 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str"!pandas._typing.IntervalClosedType 0:typing.overloadX"
+builtins.str"builtins.str"!pandas._typing.IntervalClosedType 0:typing.overloadX"
 isnapandas.core.dtypes.missing.isna
 isnapandas.core.dtypes.missing.isna":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
@@ -53973,9 +60527,9 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
-isnapandas.core.dtypes.missing.isna"
-
builtins.bool"
builtins.bool*
+Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
+isnapandas.core.dtypes.missing.isna"
+Any*
 obj
 Union[TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]],pandas._libs.tslibs.nattype.NaTType,pandas._libs.missing.NAType,None]
 TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
@@ -53998,7 +60552,7 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.complex"builtins.complex"pandas._typing.ScalarJ
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType:
 pandas._libs.missing.NAType"pandas._libs.missing.NAType
-None0:typing.overloadX"
+None0:typing.overloadX"
 notna pandas.core.dtypes.missing.notna
 notna pandas.core.dtypes.missing.notna":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*C
@@ -54028,9 +60582,9 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
-notna pandas.core.dtypes.missing.notna"
-
builtins.bool"
builtins.bool*
+Any"
numpy.ndarray"pandas._typing.ArrayLike0:typing.overloadX
+notna pandas.core.dtypes.missing.notna"
+Any*
 obj
 bUnion[pandas._typing.ScalarT,pandas._libs.tslibs.nattype.NaTType,pandas._libs.missing.NAType,None]
 pandas._typing.ScalarT
@@ -54053,7 +60607,7 @@ bUnion[pandas._typing.ScalarT,pandas._libs.tslibs.nattype.NaTType,pandas._libs.m
 builtins.complex"builtins.complexJ
 #pandas._libs.tslibs.nattype.NaTType"#pandas._libs.tslibs.nattype.NaTType:
 pandas._libs.missing.NAType"pandas._libs.missing.NAType
-None0:typing.overloadX"\
+None0:typing.overloadX"Z
 to_datetime'pandas.core.tools.datetimes.to_datetime
 to_datetime'pandas.core.tools.datetimes.to_datetime"T
 (pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.Timestamp*
@@ -54164,7 +60718,7 @@ eUnion[TypeAlias[Union[builtins.float,builtins.str]],datetime.datetime,numpy.dat
 builtins.float"builtins.float
 builtins.str"builtins.str"(pandas._typing.TimestampConvertibleTypes *+
 cache
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 to_datetime'pandas.core.tools.datetimes.to_datetime"H
 "pandas.core.series.TimestampSeries""pandas.core.series.TimestampSeries*
 arg
@@ -54175,16 +60729,14 @@ BTypeAlias[Union[TypeAlias[TypedDict],pandas.core.frame.DataFrame]]
 7Union[TypeAlias[TypedDict],pandas.core.frame.DataFrame]H
 TypeAlias[TypedDict]
 	TypedDict"pandas._typing.FulldatetimeDict:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas._typing.DictConvertible*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"pandas._typing.DictConvertible*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *.
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *.
 dayfirst
 
builtins.bool"
builtins.bool */
 	yearfirst
@@ -54221,22 +60773,24 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.float"builtins.float
 builtins.str"builtins.str"(pandas._typing.TimestampConvertibleTypes *+
 cache
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 to_datetime'pandas.core.tools.datetimes.to_datetime"Z
-+pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
-arg
-Union[typing.Sequence[Union[builtins.float,datetime.datetime]],builtins.list[builtins.str],builtins.tuple[Union[builtins.float,builtins.str,datetime.datetime]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.indexes.base.Index[Any],pandas.core.arrays.base.ExtensionArray]
-8typing.Sequence[Union[builtins.float,datetime.datetime]]u
-'Union[builtins.float,datetime.datetime] 
-builtins.float"builtins.float&
-datetime.datetime"datetime.datetime"typing.SequenceJ
++pandas.core.indexes.datetimes.DatetimeIndex"+pandas.core.indexes.datetimes.DatetimeIndex*
+
+arg
+
+Union[typing.Sequence[Union[builtins.float,datetime.date]],builtins.list[builtins.str],builtins.tuple[Union[builtins.float,builtins.str,datetime.date]],TypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]],Unknown,Unknown,pandas.core.indexes.base.Index[Any],pandas.core.arrays.base.ExtensionArray]
+4typing.Sequence[Union[builtins.float,datetime.date]]i
+#Union[builtins.float,datetime.date] 
+builtins.float"builtins.float
+
datetime.date"
datetime.date"typing.SequenceJ
 builtins.list[builtins.str]
-builtins.str"builtins.str"
builtins.list
-Dbuiltins.tuple[Union[builtins.float,builtins.str,datetime.datetime]]
-4Union[builtins.float,builtins.str,datetime.datetime] 
+builtins.str"builtins.str"
builtins.list
+@builtins.tuple[Union[builtins.float,builtins.str,datetime.date]]
+0Union[builtins.float,builtins.str,datetime.date] 
 builtins.float"builtins.float
-builtins.str"builtins.str&
-datetime.datetime"datetime.datetime"builtins.tuple
+builtins.str"builtins.str
+
datetime.date"
datetime.date"builtins.tuple
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
 Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 Any
@@ -54245,16 +60799,14 @@ Hnumpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]
 
numpy.generic"
numpy.generic"
numpy.generic"numpy.dtype"
numpy.ndarray"!numpy._typing._array_like.NDArrayN
 #pandas.core.indexes.base.Index[Any]
 Any"pandas.core.indexes.base.IndexP
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *.
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *.
 dayfirst
 
builtins.bool"
builtins.bool */
 	yearfirst
@@ -54291,7 +60843,7 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.float"builtins.float
 builtins.str"builtins.str"(pandas._typing.TimestampConvertibleTypes *+
 cache
-
builtins.bool"
builtins.bool 0:typing.overloadX"\
+
builtins.bool"
builtins.bool 0:typing.overloadX"5
 
 to_numeric$pandas.core.tools.numeric.to_numeric
 
@@ -54344,72 +60896,7 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX$
-
-to_numeric$pandas.core.tools.numeric.to_numeric"
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*
-arg
-TypeAlias[Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]]
-
-Union[TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]],builtins.complex]
-TypeAlias[Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]]
-Union[builtins.str,builtins.bytes,datetime.date,datetime.datetime,datetime.timedelta,numpy.datetime64,numpy.timedelta64,builtins.bool,builtins.int,builtins.float,pandas._libs.tslibs.timestamps.Timestamp,pandas._libs.tslibs.timedeltas.Timedelta]
-builtins.str"builtins.str 
-builtins.bytes"builtins.bytes
-
datetime.date"
datetime.date&
-datetime.datetime"datetime.datetime(
-datetime.timedelta"datetime.timedelta$
-numpy.datetime64"numpy.datetime64&
-numpy.timedelta64"numpy.timedelta64
-
builtins.bool"
builtins.bool
-builtins.int"builtins.int 
-builtins.float"builtins.floatT
-(pandas._libs.tslibs.timestamps.Timestamp"(pandas._libs.tslibs.timestamps.TimestampT
-(pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta"pandas._typing.IndexIterScalar$
-builtins.complex"builtins.complex"pandas._typing.Scalar*C
-errors7
-Literal[builtins.str]	
-builtins.str"builtins.str*
-downcast
-nTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]]
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str
-None"#pandas.core.tools.numeric._Downcast *
-
dtype_backend
-tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
-=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
-2Union[Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str"pandas._typing.DtypeBackend
-/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
-$Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
 
 to_numeric$pandas.core.tools.numeric.to_numeric"
 STypeAlias[numpy.ndarray[Any,numpy.dtype[numpy._typing._array_like._ScalarType_co]]]
@@ -54426,16 +60913,14 @@ DUnion[builtins.list[Any],builtins.tuple[Any],numpy.ndarray[Any,Any]],
 Any"builtins.tuple9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"
numpy.ndarray*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *
 downcast
 nTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]]
 cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
@@ -54458,23 +60943,21 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX
 
 to_numeric$pandas.core.tools.numeric.to_numeric"D
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series*M
 argD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"pandas.core.series.Series*
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce *
+builtins.str"builtins.str"pandas._typing.RaiseCoerce *
 downcast
 nTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]]
 cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
@@ -54497,39 +60980,19 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX"ϝ
-to_timedelta)pandas.core.tools.timedeltas.to_timedelta1
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX"|
+to_timedelta)pandas.core.tools.timedeltas.to_timedelta&
 to_timedelta)pandas.core.tools.timedeltas.to_timedelta"T
 (pandas._libs.tslibs.timedeltas.Timedelta"(pandas._libs.tslibs.timedeltas.Timedelta*
 arg
 5Union[builtins.str,builtins.float,datetime.timedelta]
 builtins.str"builtins.str 
 builtins.float"builtins.float(
-datetime.timedelta"datetime.timedelta*+
-unit+
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+datetime.timedelta"datetime.timedelta*!
+unit!
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -54598,45 +61061,23 @@ $Literal[pandas._libs.lib._NoDefault]	:
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str"3pandas._libs.tslibs.timedeltas.TimeDeltaUnitChoices
-None *
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce 0:typing.overloadX0
+builtins.str"builtins.str"pandas._typing.RaiseCoerce 0:typing.overloadX%
 to_timedelta)pandas.core.tools.timedeltas.to_timedelta"H
 "pandas.core.series.TimedeltaSeries""pandas.core.series.TimedeltaSeries*M
 argD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series*+
-unit+
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"pandas.core.series.Series*!
+unit!
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -54705,29 +61146,26 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str"3pandas._libs.tslibs.timedeltas.TimeDeltaUnitChoices
-None *
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce 0:typing.overloadX;
+builtins.str"builtins.str"pandas._typing.RaiseCoerce 0:typing.overloadX/
 to_timedelta)pandas.core.tools.timedeltas.to_timedelta"^
--pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
-arg
-Union[typing.Sequence[Union[builtins.float,datetime.timedelta]],builtins.list[Union[builtins.str,builtins.float,datetime.timedelta]],builtins.tuple[Union[builtins.str,builtins.float,datetime.timedelta]],builtins.range,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.indexes.base.Index[Any]]
+-pandas.core.indexes.timedeltas.TimedeltaIndex"-pandas.core.indexes.timedeltas.TimedeltaIndex*
+
+arg
+
+Union[pandas._typing.SequenceNotStr[Any],typing.Sequence[Union[builtins.float,datetime.timedelta]],builtins.tuple[Union[builtins.str,builtins.float,datetime.timedelta]],builtins.range,TypeAlias[Union[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]],pandas.core.indexes.base.Index[Any]]L
+"pandas._typing.SequenceNotStr[Any]
+Any"pandas._typing.SequenceNotStr
 9typing.Sequence[Union[builtins.float,datetime.timedelta]]x
 (Union[builtins.float,datetime.timedelta] 
 builtins.float"builtins.float(
-datetime.timedelta"datetime.timedelta"typing.Sequence
-Dbuiltins.list[Union[builtins.str,builtins.float,datetime.timedelta]]
-5Union[builtins.str,builtins.float,datetime.timedelta]
-builtins.str"builtins.str 
-builtins.float"builtins.float(
-datetime.timedelta"datetime.timedelta"
builtins.list
+datetime.timedelta"datetime.timedelta"typing.Sequence
 Ebuiltins.tuple[Union[builtins.str,builtins.float,datetime.timedelta]]
 5Union[builtins.str,builtins.float,datetime.timedelta]
 builtins.str"builtins.str 
@@ -54741,31 +61179,11 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 Any
 Any"
numpy.ndarray"pandas._typing.ArrayLikeN
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index*+
-unit+
-Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]#
-TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+Any"pandas.core.indexes.base.Index*!
+unit!
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -54834,16 +61252,14 @@ DUnion[pandas.core.arrays.base.ExtensionArray,numpy.ndarray[Any,Any]]P
 builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str"3pandas._libs.tslibs.timedeltas.TimeDeltaUnitChoices
-None *
-errors
-STypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
-HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
-Literal[builtins.str]	
-builtins.str"builtins.str7
+None *
+errors
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str" pandas._typing.IgnoreRaiseCoerce 0:typing.overloadX"
+builtins.str"builtins.str"pandas._typing.RaiseCoerce 0:typing.overloadX"
 uniquepandas.core.algorithms.unique
 uniquepandas.core.algorithms.unique"P
 &pandas.core.indexes.period.PeriodIndex"&pandas.core.indexes.period.PeriodIndex*\
@@ -54884,23 +61300,20 @@ DUnion[numpy.ndarray[Any,Any],pandas.core.arrays.base.ExtensionArray]9
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*P
 valuesD
 pandas.core.series.Series[Any]
-Any"pandas.core.series.Series0:typing.overloadX
+Any"pandas.core.series.Series0:typing.overloadX
 uniquepandas.core.algorithms.unique"9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray*
-values
-0Union[numpy.ndarray[Any,Any],builtins.list[Any]]9
+Any"
numpy.ndarray*E
+values9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarray,
-builtins.list[Any]
-Any"
builtins.list0:typing.overloadX
+Any"
numpy.ndarray0:typing.overloadX
 uniquepandas.core.algorithms.unique"P
 &pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray*\
 valuesP
-&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray0:typing.overloadX"6
-concat!pandas.core.reshape.concat.concat
+&pandas.core.arrays.base.ExtensionArray"&pandas.core.arrays.base.ExtensionArray0:typing.overloadX"ԗ
+concat!pandas.core.reshape.concat.concat
 concat!pandas.core.reshape.concat.concat":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 objs
@@ -54910,14 +61323,22 @@ yUnion[typing.Iterable[pandas.core.frame.DataFrame],typing.Mapping[pandas._typin
 Etyping.Mapping[pandas._typing.HashableT1,pandas.core.frame.DataFrame]R
 pandas._typing.HashableT1"
 typing.Hashable"typing.Hashable"typing.Hashable:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"typing.Mapping*
-axis
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"typing.Mapping*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisIndex *
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
 join
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
@@ -54938,17 +61359,19 @@ YUnion[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.Ha
 typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
 )builtins.tuple[pandas._typing.HashableT3]R
 pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
-names
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
+names
+4Union[builtins.list[pandas._typing.HashableT4],None]
 (builtins.list[pandas._typing.HashableT4]R
 pandas._typing.HashableT4"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list *6
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *6
 verify_integrity
 
builtins.bool"
builtins.bool **
 sort
 
builtins.bool"
builtins.bool **
 copy
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 concat!pandas.core.reshape.concat.concat"D
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series*
@@ -54989,17 +61412,19 @@ YUnion[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.Ha
 typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
 )builtins.tuple[pandas._typing.HashableT3]R
 pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
-names
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
+names
+4Union[builtins.list[pandas._typing.HashableT4],None]
 (builtins.list[pandas._typing.HashableT4]R
 pandas._typing.HashableT4"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list *6
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *6
 verify_integrity
 
builtins.bool"
builtins.bool **
 sort
 
builtins.bool"
builtins.bool **
 copy
-
builtins.bool"
builtins.bool 0:typing.overloadX
+
builtins.bool"
builtins.bool 0:typing.overloadX
 concat!pandas.core.reshape.concat.concat":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 objs
@@ -55015,14 +61440,22 @@ ktyping.Mapping[pandas._typing.HashableT1,Union[pandas.core.series.Series[Any],p
 AUnion[pandas.core.series.Series[Any],pandas.core.frame.DataFrame]D
 pandas.core.series.Series[Any]
 Any"pandas.core.series.Series:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"typing.Mapping*
-axis
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"typing.Mapping*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
 =TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
 2Union[Literal[builtins.str],Literal[builtins.int]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.AxisColumn*
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
 join
 2Union[Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
@@ -55043,11 +61476,257 @@ YUnion[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.Ha
 typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
 )builtins.tuple[pandas._typing.HashableT3]R
 pandas._typing.HashableT3"
-typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
-names
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
+names
+4Union[builtins.list[pandas._typing.HashableT4],None]
 (builtins.list[pandas._typing.HashableT4]R
 pandas._typing.HashableT4"
-typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list *6
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *6
+verify_integrity
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadX
+concat!pandas.core.reshape.concat.concat"
+NoReturn
+*
+objs
+KUnion[typing.Iterable[None],typing.Mapping[pandas._typing.HashableT1,None]]2
+typing.Iterable[None]
+None"typing.Iterable
+.typing.Mapping[pandas._typing.HashableT1,None]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable
+None"typing.Mapping*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+join
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *2
+ignore_index
+
builtins.bool"
builtins.bool *
+keys
+*typing.Iterable[pandas._typing.HashableT2]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Iterable *
+levels
+jtyping.Sequence[Union[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.HashableT3]]]
+YUnion[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.HashableT3]]
+(builtins.list[pandas._typing.HashableT3]R
+pandas._typing.HashableT3"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+)builtins.tuple[pandas._typing.HashableT3]R
+pandas._typing.HashableT3"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
+names
+4Union[builtins.list[pandas._typing.HashableT4],None]
+(builtins.list[pandas._typing.HashableT4]R
+pandas._typing.HashableT4"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *6
+verify_integrity
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadX
+concat!pandas.core.reshape.concat.concat":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+objs
+Union[typing.Iterable[Union[pandas.core.frame.DataFrame,None]],typing.Mapping[pandas._typing.HashableT1,Union[pandas.core.frame.DataFrame,None]]]
+8typing.Iterable[Union[pandas.core.frame.DataFrame,None]]q
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None"typing.Iterable
+Qtyping.Mapping[pandas._typing.HashableT1,Union[pandas.core.frame.DataFrame,None]]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashableq
+'Union[pandas.core.frame.DataFrame,None]:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None"typing.Mapping*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+join
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *2
+ignore_index
+
builtins.bool"
builtins.bool *
+keys
+*typing.Iterable[pandas._typing.HashableT2]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Iterable *
+levels
+jtyping.Sequence[Union[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.HashableT3]]]
+YUnion[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.HashableT3]]
+(builtins.list[pandas._typing.HashableT3]R
+pandas._typing.HashableT3"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+)builtins.tuple[pandas._typing.HashableT3]R
+pandas._typing.HashableT3"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
+names
+4Union[builtins.list[pandas._typing.HashableT4],None]
+(builtins.list[pandas._typing.HashableT4]R
+pandas._typing.HashableT4"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *6
+verify_integrity
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadX
+concat!pandas.core.reshape.concat.concat"D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series*
+objs
+Union[typing.Iterable[Union[pandas.core.series.Series[Any],None]],typing.Mapping[pandas._typing.HashableT1,Union[pandas.core.series.Series[Any],None]]]
+;typing.Iterable[Union[pandas.core.series.Series[Any],None]]~
+*Union[pandas.core.series.Series[Any],None]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None"typing.Iterable
+Ttyping.Mapping[pandas._typing.HashableT1,Union[pandas.core.series.Series[Any],None]]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable~
+*Union[pandas.core.series.Series[Any],None]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series
+None"typing.Mapping*
+axis
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex *
+join
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *2
+ignore_index
+
builtins.bool"
builtins.bool *
+keys
+*typing.Iterable[pandas._typing.HashableT2]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Iterable *
+levels
+jtyping.Sequence[Union[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.HashableT3]]]
+YUnion[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.HashableT3]]
+(builtins.list[pandas._typing.HashableT3]R
+pandas._typing.HashableT3"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+)builtins.tuple[pandas._typing.HashableT3]R
+pandas._typing.HashableT3"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
+names
+4Union[builtins.list[pandas._typing.HashableT4],None]
+(builtins.list[pandas._typing.HashableT4]R
+pandas._typing.HashableT4"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *6
+verify_integrity
+
builtins.bool"
builtins.bool **
+sort
+
builtins.bool"
builtins.bool **
+copy
+
builtins.bool"
builtins.bool 0:typing.overloadX
+concat!pandas.core.reshape.concat.concat":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+objs
+Union[typing.Iterable[Union[pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]],typing.Mapping[pandas._typing.HashableT1,Union[pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]]]
+Wtyping.Iterable[Union[pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]]
+FUnion[pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None"typing.Iterable
+ptyping.Mapping[pandas._typing.HashableT1,Union[pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]]R
+pandas._typing.HashableT1"
+typing.Hashable"typing.Hashable"typing.Hashable
+FUnion[pandas.core.series.Series[Any],pandas.core.frame.DataFrame,None]D
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame
+None"typing.Mapping*
+axis
+TypeAlias[Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]]
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]],TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisIndex
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.int]]]
+2Union[Literal[builtins.str],Literal[builtins.int]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.int]	
+builtins.int"builtins.int"pandas._typing.AxisColumn"pandas._typing.Axis *
+join
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str *2
+ignore_index
+
builtins.bool"
builtins.bool *
+keys
+*typing.Iterable[pandas._typing.HashableT2]R
+pandas._typing.HashableT2"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.Iterable *
+levels
+jtyping.Sequence[Union[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.HashableT3]]]
+YUnion[builtins.list[pandas._typing.HashableT3],builtins.tuple[pandas._typing.HashableT3]]
+(builtins.list[pandas._typing.HashableT3]R
+pandas._typing.HashableT3"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+)builtins.tuple[pandas._typing.HashableT3]R
+pandas._typing.HashableT3"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple"typing.Sequence *
+names
+4Union[builtins.list[pandas._typing.HashableT4],None]
+(builtins.list[pandas._typing.HashableT4]R
+pandas._typing.HashableT4"
+typing.Hashable"typing.Hashable"typing.Hashable"
builtins.list
+None *6
 verify_integrity
 
builtins.bool"
builtins.bool **
 sort
@@ -56703,8 +63382,8 @@ duplicates
 builtins.str"builtins.str*M
 _print_desc:
 Literal[builtins.bool]	
-
builtins.bool"
builtins.bool 0:typing.overloadX"
-read_clipboard#pandas.io.clipboards.read_clipboardb
+
builtins.bool"
builtins.bool 0:typing.overloadX"Ȭ
+read_clipboard#pandas.io.clipboards.read_clipboardd
 read_clipboard#pandas.io.clipboards.read_clipboard"T
 (pandas.io.parsers.readers.TextFileReader"(pandas.io.parsers.readers.TextFileReader*O
 sepD
@@ -56759,23 +63438,22 @@ nUnion[builtins.int,builtins.str,typing.Sequence[Union[builtins.str,builtins.int
 builtins.int"builtins.int"typing.Sequence:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
-None *
-usecols
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *	
+usecols	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -56927,8 +63605,9 @@ skipfooter
 builtins.str"builtins.str
 None *-
 	quotechar
-builtins.str"builtins.str *
-quoting
+builtins.str"builtins.str *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -56938,7 +63617,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *1
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *1
 doublequote
 
builtins.bool"
builtins.bool *V
 
@@ -56997,7 +63676,7 @@ BUnion[TypeAlias[Union[builtins.dict[builtins.str,Any],None]],None]
 builtins.str"builtins.str
 Any"
builtins.dict
 None"pandas._typing.StorageOptions
-None 0:typing.overloadXa
+None 0:typing.overloadXc
 read_clipboard#pandas.io.clipboards.read_clipboard"T
 (pandas.io.parsers.readers.TextFileReader"(pandas.io.parsers.readers.TextFileReader*O
 sepD
@@ -57052,23 +63731,22 @@ nUnion[builtins.int,builtins.str,typing.Sequence[Union[builtins.str,builtins.int
 builtins.int"builtins.int"typing.Sequence:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
-None *
-usecols
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *	
+usecols	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -57217,8 +63895,9 @@ skipfooter
 builtins.str"builtins.str
 None *-
 	quotechar
-builtins.str"builtins.str *
-quoting
+builtins.str"builtins.str *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -57228,7 +63907,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *1
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *1
 doublequote
 
builtins.bool"
builtins.bool *V
 
@@ -57287,7 +63966,7 @@ BUnion[TypeAlias[Union[builtins.dict[builtins.str,Any],None]],None]
 builtins.str"builtins.str
 Any"
builtins.dict
 None"pandas._typing.StorageOptions
-None 0:typing.overloadXa
+None 0:typing.overloadXc
 read_clipboard#pandas.io.clipboards.read_clipboard":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*O
 sepD
@@ -57342,23 +64021,22 @@ nUnion[builtins.int,builtins.str,typing.Sequence[Union[builtins.str,builtins.int
 builtins.int"builtins.int"typing.Sequence:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
-None *
-usecols
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *	
+usecols	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -57508,8 +64186,9 @@ skipfooter
 builtins.str"builtins.str
 None *-
 	quotechar
-builtins.str"builtins.str *
-quoting
+builtins.str"builtins.str *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -57519,7 +64198,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *1
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *1
 doublequote
 
builtins.bool"
builtins.bool *V
 
@@ -57578,8 +64257,8 @@ BUnion[TypeAlias[Union[builtins.dict[builtins.str,Any],None]],None]
 builtins.str"builtins.str
 Any"
builtins.dict
 None"pandas._typing.StorageOptions
-None 0:typing.overloadX"
-read_csv"pandas.io.parsers.readers.read_csvn
+None 0:typing.overloadX"
+read_csv"pandas.io.parsers.readers.read_csvp
 read_csv"pandas.io.parsers.readers.read_csv"T
 (pandas.io.parsers.readers.TextFileReader"(pandas.io.parsers.readers.TextFileReader*
 filepath_or_buffer
@@ -57634,23 +64313,22 @@ nUnion[builtins.int,builtins.str,typing.Sequence[Union[builtins.str,builtins.int
 builtins.int"builtins.int"typing.Sequence:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
-None *
-usecols
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *	
+usecols	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -57818,8 +64496,9 @@ DUnion[builtins.dict[typing.Hashable,builtins.str],builtins.str,None]~
 builtins.str"builtins.str
 None *-
 	quotechar
-builtins.str"builtins.str *
-quoting
+builtins.str"builtins.str *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -57829,7 +64508,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *1
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *1
 doublequote
 
builtins.bool"
builtins.bool *V
 
@@ -57899,7 +64578,7 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXm
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXo
 read_csv"pandas.io.parsers.readers.read_csv"T
 (pandas.io.parsers.readers.TextFileReader"(pandas.io.parsers.readers.TextFileReader*
 filepath_or_buffer
@@ -57954,23 +64633,22 @@ nUnion[builtins.int,builtins.str,typing.Sequence[Union[builtins.str,builtins.int
 builtins.int"builtins.int"typing.Sequence:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
-None *
-usecols
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *	
+usecols	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -58135,8 +64813,9 @@ DUnion[builtins.dict[typing.Hashable,builtins.str],builtins.str,None]~
 builtins.str"builtins.str
 None *-
 	quotechar
-builtins.str"builtins.str *
-quoting
+builtins.str"builtins.str *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -58146,7 +64825,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *1
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *1
 doublequote
 
builtins.bool"
builtins.bool *V
 
@@ -58216,7 +64895,7 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXm
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXo
 read_csv"pandas.io.parsers.readers.read_csv":
 pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
 filepath_or_buffer
@@ -58271,23 +64950,22 @@ nUnion[builtins.int,builtins.str,typing.Sequence[Union[builtins.str,builtins.int
 builtins.int"builtins.int"typing.Sequence:
 Literal[builtins.bool]	
 
builtins.bool"
builtins.bool
-None *
-usecols
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+None *	
+usecols	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -58453,8 +65131,9 @@ DUnion[builtins.dict[typing.Hashable,builtins.str],builtins.str,None]~
 builtins.str"builtins.str
 None *-
 	quotechar
-builtins.str"builtins.str *
-quoting
+builtins.str"builtins.str *
+quoting
+tTypeAlias[TypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]]
 iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]]
 ^Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.int],Literal[builtins.int]]7
 Literal[builtins.int]	
@@ -58464,7 +65143,7 @@ iTypeAlias[Union[Literal[builtins.int],Literal[builtins.int],Literal[builtins.in
 Literal[builtins.int]	
 builtins.int"builtins.int7
 Literal[builtins.int]	
-builtins.int"builtins.int"pandas._typing.CSVQuoting *1
+builtins.int"builtins.int"pandas._typing.CSVQuotingCompat"pandas._typing.CSVQuoting *1
 doublequote
 
builtins.bool"
builtins.bool *V
 
@@ -58534,38 +65213,246 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX"
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX"
 
-read_excel pandas.io.excel._base.read_excelO
+read_excel pandas.io.excel._base.read_excelR
 
-read_excel pandas.io.excel._base.read_excel"
-Kbuiltins.dict[Union[builtins.int,builtins.str],pandas.core.frame.DataFrame]`
+read_excel pandas.io.excel._base.read_excel"
+Abuiltins.dict[pandas._typing.IntStrT,pandas.core.frame.DataFrame]O
+pandas._typing.IntStrT"
+builtins.object"builtins.object"builtins.object:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.dict*
+io
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
+)pandas._typing.ReadBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.ReadBufferB
+pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile
+Any
+Any
+Any
+Any*
+
+sheet_name
+%builtins.list[pandas._typing.IntStrT]O
+pandas._typing.IntStrT"
+builtins.object"builtins.object"builtins.object"
builtins.list*
+header
+6Union[builtins.int,typing.Sequence[builtins.int],None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+None *
+names
+Union[TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]],None]
+TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]]
+Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]
+0typing.MutableSequence[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.MutableSequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
+builtins.range"builtins.range"pandas._typing.ListLikeHashable
+None *
+	index_col
+CUnion[builtins.int,typing.Sequence[builtins.int],builtins.str,None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+builtins.str"builtins.str
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None"pandas._typing.UsecolsArgType *
+dtype
+Union[builtins.str,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[builtins.str,Union[builtins.str,Unknown]],None]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype
+8typing.Mapping[builtins.str,Union[builtins.str,Unknown]]
+builtins.str"builtins.str?
+Union[builtins.str,Unknown]
+builtins.str"builtins.str"typing.Mapping
+None *
+engine
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ExcelReadEngine
+None *
+
+converters
+\Union[typing.Mapping[Union[builtins.int,builtins.str],CallableType[builtins.function]],None]
+Ptyping.Mapping[Union[builtins.int,builtins.str],CallableType[builtins.function]]`
  Union[builtins.int,builtins.str]
 builtins.int"builtins.int
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"typing.Mapping
+None *
+true_values
+,Union[typing.Iterable[typing.Hashable],None]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable
+None *
+false_values
+,Union[typing.Iterable[typing.Hashable],None]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable
+None *
+skiprows
+VUnion[builtins.int,typing.Sequence[builtins.int],CallableType[builtins.function],None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *Q
+nrowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+	na_values
+rUnion[typing.Sequence[builtins.str],builtins.dict[Union[builtins.str,builtins.int],typing.Sequence[builtins.str]]]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+Mbuiltins.dict[Union[builtins.str,builtins.int],typing.Sequence[builtins.str]]`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.intN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence"
builtins.dict *5
+keep_default_na
+
builtins.bool"
builtins.bool */
+	na_filter
+
builtins.bool"
builtins.bool *-
+verbose
+
builtins.bool"
builtins.bool *
+parse_dates
+Union[builtins.bool,typing.Sequence[builtins.int],typing.Sequence[Union[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]],builtins.dict[builtins.str,Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]]]
+
builtins.bool"
builtins.boolN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+Styping.Sequence[Union[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]]
+BUnion[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.SequenceN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence"typing.Sequence
+\builtins.dict[builtins.str,Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]]
+builtins.str"builtins.str
+@Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]N
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list"
builtins.dict *
+date_format
+DUnion[builtins.dict[typing.Hashable,builtins.str],builtins.str,None]~
++builtins.dict[typing.Hashable,builtins.str]"
+typing.Hashable"typing.Hashable
+builtins.str"builtins.str"
builtins.dict
+builtins.str"builtins.str
+None *U
+	thousandsD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *+
+decimal
+builtins.str"builtins.str *S
+commentD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *.
+
+skipfooter
+builtins.int"builtins.int *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions *
+
dtype_backend
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.DtypeBackend
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXQ
+
+read_excel pandas.io.excel._base.read_excel"
+7builtins.dict[builtins.str,pandas.core.frame.DataFrame]
 builtins.str"builtins.str:
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.dict*
-io
-Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],builtins.bytes,pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.dict*
+io
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
 8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
 -Union[builtins.str,os.PathLike[builtins.str]]
 builtins.str"builtins.strF
 os.PathLike[builtins.str]
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
 )pandas._typing.ReadBuffer[builtins.bytes] 
-builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer 
-builtins.bytes"builtins.bytesB
+builtins.bytes"builtins.bytes"pandas._typing.ReadBufferB
 pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile
 Any
 Any
 Any
-Any*
+Any*
 
-sheet_name
-;Union[builtins.list[Union[builtins.int,builtins.str]],None]
-/builtins.list[Union[builtins.int,builtins.str]]`
- Union[builtins.int,builtins.str]
-builtins.int"builtins.int
-builtins.str"builtins.str"
builtins.list
+sheet_name
 None*
 header
 6Union[builtins.int,typing.Sequence[builtins.int],None]
@@ -58587,33 +65474,31 @@ sheet_name
 pandas._typing.HashableT"
 typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
 builtins.range"builtins.range"pandas._typing.ListLikeHashable
-None *
-	index_col
-6Union[builtins.int,typing.Sequence[builtins.int],None]
+None *
+	index_col
+CUnion[builtins.int,typing.Sequence[builtins.int],builtins.str,None]
 builtins.int"builtins.intN
 typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
-None *
-
-usecols
-
-Union[builtins.str,TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]]
-builtins.str"builtins.str
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+builtins.int"builtins.int"typing.Sequence
+builtins.str"builtins.str
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -58640,9 +65525,11 @@ $typing.MutableSequence[builtins.str]
 builtins.str"builtins.str?
 Union[builtins.str,Unknown]
 builtins.str"builtins.str"typing.Mapping
-None *
-engine
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+None *
+engine
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -58650,7 +65537,9 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ExcelReadEngine
 None *
 
 converters
@@ -58755,30 +65644,34 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXM
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXS
 
-read_excel pandas.io.excel._base.read_excel":
-pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
-io
-Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],builtins.bytes,pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
+read_excel pandas.io.excel._base.read_excel"
+Kbuiltins.dict[Union[builtins.int,builtins.str],pandas.core.frame.DataFrame]`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str:
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame"
builtins.dict*
+io
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
 8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
 -Union[builtins.str,os.PathLike[builtins.str]]
 builtins.str"builtins.strF
 os.PathLike[builtins.str]
 builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
 )pandas._typing.ReadBuffer[builtins.bytes] 
-builtins.bytes"builtins.bytes"pandas._typing.ReadBuffer 
-builtins.bytes"builtins.bytesB
+builtins.bytes"builtins.bytes"pandas._typing.ReadBufferB
 pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile
 Any
 Any
 Any
-Any*r
+Any*
 
-sheet_name`
+sheet_name
+/builtins.list[Union[builtins.int,builtins.str]]`
  Union[builtins.int,builtins.str]
 builtins.int"builtins.int
-builtins.str"builtins.str *
+builtins.str"builtins.str"
builtins.list*
 header
 6Union[builtins.int,typing.Sequence[builtins.int],None]
 builtins.int"builtins.intN
@@ -58799,33 +65692,31 @@ sheet_name`
 pandas._typing.HashableT"
 typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
 builtins.range"builtins.range"pandas._typing.ListLikeHashable
-None *
-	index_col
-6Union[builtins.int,typing.Sequence[builtins.int],None]
+None *
+	index_col
+CUnion[builtins.int,typing.Sequence[builtins.int],builtins.str,None]
 builtins.int"builtins.intN
 typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.Sequence
-None *
-
-usecols
-
-Union[builtins.str,TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]]
-builtins.str"builtins.str
-TypeAlias[Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]]
-Union[typing.MutableSequence[builtins.str],builtins.tuple[builtins.str],typing.Sequence[builtins.int],pandas.core.series.Series[Any],pandas.core.indexes.base.Index[Any],numpy.ndarray[Any,Any],CallableType[builtins.function],None]\
-$typing.MutableSequence[builtins.str]
-builtins.str"builtins.str"typing.MutableSequenceL
-builtins.tuple[builtins.str]
-builtins.str"builtins.str"builtins.tupleN
-typing.Sequence[builtins.int]
-builtins.int"builtins.int"typing.SequenceD
-pandas.core.series.Series[Any]
-Any"pandas.core.series.SeriesN
+builtins.int"builtins.int"typing.Sequence
+builtins.str"builtins.str
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
 #pandas.core.indexes.base.Index[Any]
-Any"pandas.core.indexes.base.Index9
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
 numpy.ndarray[Any,Any]
 Any
-Any"
numpy.ndarrayK
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
 CallableType[builtins.function]&
 builtins.function"builtins.function
 None"pandas._typing.UsecolsArgType *
@@ -58852,9 +65743,13 @@ $typing.MutableSequence[builtins.str]
 builtins.str"builtins.str?
 Union[builtins.str,Unknown]
 builtins.str"builtins.str"typing.Mapping
-None *
-engine
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+None *
+engine
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -58862,7 +65757,220 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ExcelReadEngine
+None *
+
+converters
+\Union[typing.Mapping[Union[builtins.int,builtins.str],CallableType[builtins.function]],None]
+Ptyping.Mapping[Union[builtins.int,builtins.str],CallableType[builtins.function]]`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.strK
+CallableType[builtins.function]&
+builtins.function"builtins.function"typing.Mapping
+None *
+true_values
+,Union[typing.Iterable[typing.Hashable],None]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable
+None *
+false_values
+,Union[typing.Iterable[typing.Hashable],None]W
+ typing.Iterable[typing.Hashable]"
+typing.Hashable"typing.Hashable"typing.Iterable
+None *
+skiprows
+VUnion[builtins.int,typing.Sequence[builtins.int],CallableType[builtins.function],None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None *Q
+nrowsD
+Union[builtins.int,None]
+builtins.int"builtins.int
+None *
+	na_values
+rUnion[typing.Sequence[builtins.str],builtins.dict[Union[builtins.str,builtins.int],typing.Sequence[builtins.str]]]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence
+Mbuiltins.dict[Union[builtins.str,builtins.int],typing.Sequence[builtins.str]]`
+ Union[builtins.str,builtins.int]
+builtins.str"builtins.str
+builtins.int"builtins.intN
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.Sequence"
builtins.dict *5
+keep_default_na
+
builtins.bool"
builtins.bool */
+	na_filter
+
builtins.bool"
builtins.bool *-
+verbose
+
builtins.bool"
builtins.bool *
+parse_dates
+Union[builtins.bool,typing.Sequence[builtins.int],typing.Sequence[Union[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]],builtins.dict[builtins.str,Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]]]
+
builtins.bool"
builtins.boolN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+Styping.Sequence[Union[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]]
+BUnion[typing.Sequence[builtins.str],typing.Sequence[builtins.int]]N
+typing.Sequence[builtins.str]
+builtins.str"builtins.str"typing.SequenceN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence"typing.Sequence
+\builtins.dict[builtins.str,Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]]
+builtins.str"builtins.str
+@Union[typing.Sequence[builtins.int],builtins.list[builtins.str]]N
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.SequenceJ
+builtins.list[builtins.str]
+builtins.str"builtins.str"
builtins.list"
builtins.dict *
+date_format
+DUnion[builtins.dict[typing.Hashable,builtins.str],builtins.str,None]~
++builtins.dict[typing.Hashable,builtins.str]"
+typing.Hashable"typing.Hashable
+builtins.str"builtins.str"
builtins.dict
+builtins.str"builtins.str
+None *U
+	thousandsD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *+
+decimal
+builtins.str"builtins.str *S
+commentD
+Union[builtins.str,None]
+builtins.str"builtins.str
+None *.
+
+skipfooter
+builtins.int"builtins.int *
+storage_options
+6TypeAlias[Union[builtins.dict[builtins.str,Any],None]]
++Union[builtins.dict[builtins.str,Any],None]W
+builtins.dict[builtins.str,Any]
+builtins.str"builtins.str
+Any"
builtins.dict
+None"pandas._typing.StorageOptions *
+
dtype_backend
+tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[Literal[pandas._libs.lib._NoDefault]]]
+=TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]]
+2Union[Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.DtypeBackend
+/TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
+$Literal[pandas._libs.lib._NoDefault]	:
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadXQ
+
+read_excel pandas.io.excel._base.read_excel":
+pandas.core.frame.DataFrame"pandas.core.frame.DataFrame*
+io
+Union[TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]],pandas._typing.ReadBuffer[builtins.bytes],pandas.io.excel._base.ExcelFile,Any,Any,Any,Any]
+8TypeAlias[Union[builtins.str,os.PathLike[builtins.str]]]
+-Union[builtins.str,os.PathLike[builtins.str]]
+builtins.str"builtins.strF
+os.PathLike[builtins.str]
+builtins.str"builtins.str"os.PathLike"pandas._typing.FilePathh
+)pandas._typing.ReadBuffer[builtins.bytes] 
+builtins.bytes"builtins.bytes"pandas._typing.ReadBufferB
+pandas.io.excel._base.ExcelFile"pandas.io.excel._base.ExcelFile
+Any
+Any
+Any
+Any*r
+
+sheet_name`
+ Union[builtins.int,builtins.str]
+builtins.int"builtins.int
+builtins.str"builtins.str *
+header
+6Union[builtins.int,typing.Sequence[builtins.int],None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
+None *
+names
+Union[TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]],None]
+TypeAlias[Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]]
+Union[typing.MutableSequence[pandas._typing.HashableT],numpy.ndarray[Any,Any],builtins.tuple[pandas._typing.HashableT],builtins.range]
+0typing.MutableSequence[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"typing.MutableSequence9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray
+(builtins.tuple[pandas._typing.HashableT]Q
+pandas._typing.HashableT"
+typing.Hashable"typing.Hashable"typing.Hashable"builtins.tuple 
+builtins.range"builtins.range"pandas._typing.ListLikeHashable
+None *
+	index_col
+CUnion[builtins.int,typing.Sequence[builtins.int],builtins.str,None]
+builtins.int"builtins.intN
+typing.Sequence[builtins.int]
+builtins.int"builtins.int"typing.Sequence
 builtins.str"builtins.str
+None *
+usecols
+Union[builtins.str,TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]]
+Union[pandas._typing.SequenceNotStr[typing.Hashable],builtins.range,TypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]],CallableType[builtins.function],None]s
+.pandas._typing.SequenceNotStr[typing.Hashable]"
+typing.Hashable"typing.Hashable"pandas._typing.SequenceNotStr 
+builtins.range"builtins.range
+kTypeAlias[Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]]
+`Union[pandas.core.indexes.base.Index[Any],pandas.core.series.Series[Any],numpy.ndarray[Any,Any]]N
+#pandas.core.indexes.base.Index[Any]
+Any"pandas.core.indexes.base.IndexD
+pandas.core.series.Series[Any]
+Any"pandas.core.series.Series9
+numpy.ndarray[Any,Any]
+Any
+Any"
numpy.ndarray"pandas._typing.AnyArrayLikeK
+CallableType[builtins.function]&
+builtins.function"builtins.function
+None"pandas._typing.UsecolsArgType *
+dtype
+Union[builtins.str,TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]],typing.Mapping[builtins.str,Union[builtins.str,Unknown]],None]
+builtins.str"builtins.str	
+TypeAlias[Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]]
+Union[pandas.core.dtypes.base.ExtensionDtype,TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]]P
+&pandas.core.dtypes.base.ExtensionDtype"&pandas.core.dtypes.base.ExtensionDtype
+TypeAlias[Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]]
+Union[builtins.str,numpy.dtype[numpy.generic],Type[builtins.str],Type[builtins.complex],Type[builtins.bool],Type[builtins.object]]
+builtins.str"builtins.strI
+numpy.dtype[numpy.generic]
+
numpy.generic"
numpy.generic"numpy.dtype:
+Type[builtins.str]
+builtins.str"builtins.str"typeF
+Type[builtins.complex]$
+builtins.complex"builtins.complex"type=
+Type[builtins.bool]
+
builtins.bool"
builtins.bool"typeC
+Type[builtins.object]"
+builtins.object"builtins.object"type"pandas._typing.NpDtype"pandas._typing.Dtype
+8typing.Mapping[builtins.str,Union[builtins.str,Unknown]]
+builtins.str"builtins.str?
+Union[builtins.str,Unknown]
+builtins.str"builtins.str"typing.Mapping
+None *
+engine
+Union[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+tUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str7
+Literal[builtins.str]	
+builtins.str"builtins.str"pandas._typing.ExcelReadEngine
 None *
 
 converters
@@ -59334,8 +66442,8 @@ HUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 	chunksize
 None *
 kwargs
-Any0:typing.overloadX"
-	read_jsonpandas.io.json._json.read_json9
+Any0:typing.overloadX"
+	read_jsonpandas.io.json._json.read_json;
 	read_jsonpandas.io.json._json.read_json"
 ?pandas.io.json._json.JsonReader[pandas.core.series.Series[Any]]D
 pandas.core.series.Series[Any]
@@ -59406,9 +66514,11 @@ iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.st
 keep_default_dates
 
builtins.bool"
builtins.bool *3
 
precise_float
-
builtins.bool"
builtins.bool *
-	date_unit
-cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],None]7
+
builtins.bool"
builtins.bool *
+	date_unit
+uUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]],None]
+iTypeAlias[Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]]
+^Union[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal[builtins.str]]7
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
@@ -59416,7 +66526,7 @@ cUnion[Literal[builtins.str],Literal[builtins.str],Literal[builtins.str],Literal
 Literal[builtins.str]	
 builtins.str"builtins.str7
 Literal[builtins.str]	
-builtins.str"builtins.str
+builtins.str"builtins.str"pandas._typing.TimeUnit
 None *T
 encodingD
 Union[builtins.str,None]
@@ -59481,7 +66591,7 @@ tUnion[TypeAlias[Union[Literal[builtins.str],Literal[builtins.str]]],TypeAlias[L
 builtins.str"builtins.str"pandas._typing.DtypeBackend
 /TypeAlias[Literal[pandas._libs.lib._NoDefault]]d
 $Literal[pandas._libs.lib._NoDefault]	:
-pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX;
+pandas._libs.lib._NoDefault"pandas._libs.lib._NoDefault"pandas._libs.lib.NoDefault 0:typing.overloadX=
 	read_jsonpandas.io.json._json.read_json"
  new org.sonar.python.tree.IPythonTreeMaker(result.locationMap()).fileInput(ast))
+      .doesNotThrowAnyException();
+  }
+
   @Test
   void testParseNotebookWithEscapedChars() throws IOException {
     var inputFile = createInputFile(baseDir, "notebook_with_escaped_chars.ipynb", InputFile.Status.CHANGED, InputFile.Type.MAIN);
@@ -260,6 +290,57 @@ void testParseNotebookSingleLine() throws IOException {
     assertThat(result.locationMap()).containsEntry(8, new IPythonLocation(1, 636, mapToColumnMappingList(Map.of(1, 1, 2, 1, 0, 1)), true));
   }
 
+  @Test
+  void testParseNotebookWithMultilineArrayElementWithoutTrailingNewline() throws IOException {
+    // "source": ["x = 1\ny", " = 2"] - the first element has no trailing newline, so its last split
+    // line ("y") is continued, not terminated, by the next array element (" = 2"), giving 2 python lines
+    // ("x = 1" and "y = 2") rather than 3. Before the fix, each array element always got its own
+    // locationMap entry regardless of whether the previous one ended with a newline, producing one more
+    // entry than there are physical lines and misaligning every location after it.
+    var inputFile = createInputFile(baseDir, "notebook_multiline_string_in_array_no_trailing_newline.ipynb", InputFile.Status.CHANGED, InputFile.Type.MAIN);
+
+    var resultOptional = IpynbNotebookParser.parseNotebook(inputFile);
+
+    assertThat(resultOptional).isPresent();
+
+    var result = resultOptional.get();
+    assertThat(result.contents()).hasLineCount(3);
+    assertThat(result.locationMap().keySet()).hasSize(3);
+    //"x = 1"
+    assertThat(result.locationMap()).extractingByKey(1).isEqualTo(new IPythonLocation(9, 9, List.of(), true));
+    //"y = 2" ("y" starts the line, " = 2" from the next array element continues it)
+    assertThat(result.locationMap()).extractingByKey(2).isEqualTo(new IPythonLocation(9, 16, List.of(), true));
+    // the cell delimiter
+    assertThat(result.locationMap()).extractingByKey(3).isEqualTo(new IPythonLocation(10, 9, List.of(), false));
+  }
+
+  @Test
+  void testParseNotebookWithMultilineStringInSourceArray() throws IOException {
+    var inputFile = createInputFile(baseDir, "notebook_multiline_string_in_array.ipynb", InputFile.Status.CHANGED, InputFile.Type.MAIN);
+
+    var resultOptional = IpynbNotebookParser.parseNotebook(inputFile);
+
+    assertThat(resultOptional).isPresent();
+
+    var result = resultOptional.get();
+    // 11 python lines packed into the single "source" array element, plus the cell delimiter.
+    // Before the fix, only 2 entries were produced (the whole array element counted as a single line),
+    // which made TokenEnricher fail with "No IPythonLocation found for line 3".
+    assertThat(result.contents()).hasLineCount(12);
+    assertThat(result.locationMap().keySet()).hasSize(12);
+    //"print(\"Test 1\")"
+    assertThat(result.locationMap()).extractingByKey(1).isEqualTo(new IPythonLocation(9, 9, mapToColumnMappingList(Map.of(6, 1, 13, 1)), true));
+    //"testA = \"1\""
+    assertThat(result.locationMap()).extractingByKey(2).isEqualTo(new IPythonLocation(9, 28, mapToColumnMappingList(Map.of(8, 1, 10, 1)), true));
+    // two consecutive empty lines
+    assertThat(result.locationMap()).extractingByKey(7).isEqualTo(new IPythonLocation(9, 111, List.of(), true));
+    assertThat(result.locationMap()).extractingByKey(8).isEqualTo(new IPythonLocation(9, 113, List.of(), true));
+    //"print(testAll)" (last content line, no trailing newline in the JSON value)
+    assertThat(result.locationMap()).extractingByKey(11).isEqualTo(new IPythonLocation(9, 150, List.of(), true));
+    // the cell delimiter
+    assertThat(result.locationMap()).extractingByKey(12).isEqualTo(new IPythonLocation(9, 164, List.of(), false));
+  }
+
   @Test
   void testParseNotebook1() throws IOException {
     var inputFile = createInputFile(baseDir, "notebook_no_code.ipynb", InputFile.Status.CHANGED, InputFile.Type.MAIN);
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/PythonInputFileImplTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/PythonInputFileImplTest.java
index 1d5b9b914e..00b428a412 100755
--- a/python-frontend/src/test/java/org/sonar/plugins/python/PythonInputFileImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/PythonInputFileImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,7 +19,7 @@
 import java.io.IOException;
 import org.junit.jupiter.api.Test;
 import org.sonar.api.batch.fs.InputFile;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
 import org.sonar.plugins.python.PythonInputFile.Kind;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/PythonTestFileClassifierTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/PythonTestFileClassifierTest.java
new file mode 100644
index 0000000000..f6a3a801ac
--- /dev/null
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/PythonTestFileClassifierTest.java
@@ -0,0 +1,271 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python;
+
+import java.util.List;
+import java.util.Optional;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.sonar.api.batch.fs.InputFile;
+import org.sonar.api.config.Configuration;
+import org.sonar.plugins.python.api.tree.AliasedName;
+import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.plugins.python.api.tree.ImportName;
+import org.sonar.plugins.python.api.tree.StatementList;
+import org.sonar.python.parser.PythonParser;
+import org.sonar.python.tree.PythonTreeMaker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class PythonTestFileClassifierTest {
+
+  @ParameterizedTest
+  @ValueSource(strings = {
+    "tests/helpers.py",
+    "src/TESTING/factories.py",
+    "src/Test/helpers.py",
+    "src/Tests/helpers.py",
+    "src/Testing/factories.py",
+    "src/test/conftest.py",
+    "conftest.py",
+    "src/test_module.py",
+    "test_module.py",
+    "src/testExample.py",
+    "src/Test.py",
+    "src/TestModule.py",
+    "src/module_test.py",
+    "module_test.py",
+    "src/module_tests.py",
+    "module_tests.py",
+    "src/module_doctest.py",
+    "module_doctest.py",
+    "src/module_doctests.py",
+    "module_doctests.py"
+  })
+  void path_signals_include_test_support_files_and_boundary_aware_filenames(String path) {
+    assertThat(classifier().looksLikeTestFile(file(path), null)).isTrue();
+  }
+
+  @ParameterizedTest
+  @ValueSource(strings = {
+    "",
+    "src/production.py",
+    "src/module.py",
+    "src/latest/module.py",
+    "src/greatest.py",
+    "src/latest_adopted_release_filter.py",
+    "src/primetest.py",
+    "src/stubtest.py",
+    "src/souptest.py",
+    "src/send_test_email.py",
+    "src/testExample.txt",
+    "src/testexample.py",
+    "src/Testing.py",
+    "src/Testimonial.py"
+  })
+  void non_test_paths_are_not_classified_without_an_ast_signal(String path) {
+    assertThat(classifier().looksLikeTestFile(file(path), null)).isFalse();
+  }
+
+  @Test
+  void shared_classifier_disables_the_python_detector_when_test_sources_are_configured() {
+    var configuration = config();
+    when(configuration.get("sonar.tests")).thenReturn(Optional.of("tests"));
+
+    assertThat(new PythonTestFileClassifier(configuration)
+      .looksLikeTestFile(file("src/production.py"), parse("import pytest\n"))).isFalse();
+    assertThat(new PythonTestFileClassifier(configuration)
+      .looksLikeTestFile(file("src/TestModule.py"), null)).isFalse();
+  }
+
+  @ParameterizedTest
+  @ValueSource(strings = {
+    "import pytest as pt\n",
+    "from unittest.mock import Mock\n",
+    "import doctest\n",
+    "from django.test import TestCase\n",
+    "from django import test\n",
+    "from twisted import trial\n",
+    "import hypothesis.strategies as st\n",
+    "import robot\n",
+    "import behave\n",
+    "import pytest_bdd\n",
+    "import nose\n",
+    "import nose2\n",
+    "from twisted.trial import unittest\n",
+    "import testtools\n",
+    "import pytest_mock\n",
+    "import factory_boy\n",
+    "import freezegun\n",
+    "import requests_mock\n",
+    "import respx\n",
+    "import httpretty\n",
+    "import moto\n",
+    "import testcontainers\n"
+  })
+  void test_framework_and_utility_imports_are_detected(String code) {
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse(code))).isTrue();
+  }
+
+  @Test
+  void non_test_submodule_imports_are_not_classified() {
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("from django import forms\n"))).isFalse();
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("from twisted import internet\n"))).isFalse();
+  }
+
+  @ParameterizedTest
+  @ValueSource(strings = {
+    "import mock\n",
+    "import fixtures\n",
+    "import factory\n",
+    "import responses\n",
+    "import vcr\n"
+  })
+  void generic_utility_imports_alone_are_not_classified(String code) {
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse(code))).isFalse();
+  }
+
+  @Test
+  void test_shaped_top_level_declarations_require_a_majority_of_two_or_more() {
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("class TestService:\n    pass\n"))).isFalse();
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("def test():\n    pass\n"))).isFalse();
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("""
+      class TestService:
+          pass
+      def test_synchronous():
+          pass
+      async def test_asynchronous():
+          pass
+      class ProductionService:
+          pass
+      """))).isTrue();
+  }
+
+  @Test
+  void test_shaped_declarations_are_counted_with_other_top_level_classes() {
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("""
+      class Formatter:
+          pass
+      class HtmlFormatter:
+          pass
+      class TextFormatter:
+          pass
+      class JsonFormatter:
+          pass
+      class XmlFormatter:
+          pass
+      def test():
+          pass
+      """))).isFalse();
+  }
+
+  @Test
+  void lowercase_continuations_after_test_are_not_test_shaped() {
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("class Testing:\n    pass\n"))).isFalse();
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("""
+      def testing():
+          pass
+      def testimony():
+          pass
+      def helper():
+          pass
+      """))).isFalse();
+  }
+
+  @Test
+  void test_shaped_declaration_ratio_requires_a_strict_majority() {
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("""
+      def test_first():
+          pass
+      def helper():
+          pass
+      """))).isFalse();
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("""
+      def test_first():
+          pass
+      def test_second():
+          pass
+      def first_helper():
+          pass
+      def second_helper():
+          pass
+      """))).isFalse();
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("pass\n"))).isFalse();
+  }
+
+  @Test
+  void nested_test_signals_do_not_affect_top_level_classification() {
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("""
+      def helper():
+          import pytest
+          def test_inner():
+              pass
+      """))).isFalse();
+  }
+
+  @Test
+  void path_signal_is_available_when_parsing_fails() {
+    assertThat(classifier().looksLikeTestFile(file("tests/helpers.py"), null)).isTrue();
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), null)).isFalse();
+  }
+
+  @Test
+  void absent_or_relative_import_input_does_not_indicate_a_test_file() {
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), parse("from . import pytest\n"))).isFalse();
+  }
+
+  @Test
+  void missing_ast_nodes_do_not_classify_a_file_as_a_test() {
+    var fileInput = mock(FileInput.class);
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), fileInput)).isFalse();
+
+    var aliasedName = mock(AliasedName.class);
+    var importName = mock(ImportName.class);
+    var statements = mock(StatementList.class);
+    when(importName.modules()).thenReturn(List.of(aliasedName));
+    when(statements.statements()).thenReturn(List.of(importName));
+    when(fileInput.statements()).thenReturn(statements);
+
+    assertThat(classifier().looksLikeTestFile(file("src/production.py"), fileInput)).isFalse();
+  }
+
+  private static PythonTestFileClassifier classifier() {
+    return new PythonTestFileClassifier(config());
+  }
+
+  private static Configuration config() {
+    var configuration = mock(Configuration.class);
+    when(configuration.get(anyString())).thenReturn(Optional.empty());
+    when(configuration.getBoolean(anyString())).thenReturn(Optional.empty());
+    return configuration;
+  }
+
+  private static InputFile file(String path) {
+    var inputFile = mock(InputFile.class);
+    when(inputFile.relativePath()).thenReturn(path);
+    return inputFile;
+  }
+
+  private static FileInput parse(String code) {
+    var astNode = PythonParser.create().parse(code);
+    return new PythonTreeMaker().fileInput(astNode);
+  }
+}
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/SonarQubePythonFileTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/SonarQubePythonFileTest.java
index 750aa234ed..a19f57a4be 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/SonarQubePythonFileTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/SonarQubePythonFileTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/ParserTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/ParserTest.java
index f3cd572004..386caea11f 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/ParserTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/ParserTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonCustomRuleRepositoryWrapperTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonCustomRuleRepositoryWrapperTest.java
index ec6dac62fb..a4872342fc 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonCustomRuleRepositoryWrapperTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonCustomRuleRepositoryWrapperTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonVersionUtilsTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonVersionUtilsTest.java
index 49bc32f285..ded0e54111 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonVersionUtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonVersionUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,12 +20,14 @@
 import java.util.Set;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 import org.slf4j.event.Level;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.sonar.plugins.python.api.PythonVersionUtils.Version.V_310;
 import static org.sonar.plugins.python.api.PythonVersionUtils.Version.V_311;
 import static org.sonar.plugins.python.api.PythonVersionUtils.Version.V_312;
@@ -72,11 +74,73 @@ void bugfix_versions() {
     assertThat(PythonVersionUtils.fromString("3.12.1")).containsExactlyInAnyOrder(V_312);
   }
 
+  @Test
+  void comparison_specifiers() {
+    assertThat(PythonVersionUtils.fromString(">=3.10")).containsExactly(V_310, V_311, V_312, V_313, V_314);
+    assertThat(PythonVersionUtils.fromString(">3.10")).containsExactly(V_311, V_312, V_313, V_314);
+    assertThat(PythonVersionUtils.fromString(">=3,<=3.10")).containsExactly(V_38, V_39, V_310);
+    assertThat(PythonVersionUtils.fromString(">=3,<3.10")).containsExactly(V_38, V_39);
+    assertThat(PythonVersionUtils.fromString(">=3.10.1,<3.12.4")).containsExactly(V_310, V_311);
+    assertThat(PythonVersionUtils.fromString("<3.12")).containsExactly(V_38, V_39, V_310, V_311);
+    assertThat(PythonVersionUtils.fromString(">=2.7,<3.12")).containsExactly(V_38, V_39, V_310, V_311);
+    assertThat(PythonVersionUtils.fromString(" >= 3.9 , < 3.12 ")).containsExactly(V_39, V_310, V_311);
+  }
+
+  @Test
+  void equality_and_exclusion_specifiers() {
+    assertThat(PythonVersionUtils.fromString("==3.11")).containsExactly(V_311);
+    assertThat(PythonVersionUtils.fromString("==3.*")).hasSameElementsAs(allVersions);
+    assertThat(PythonVersionUtils.fromString("==3.11.*")).containsExactly(V_311);
+    assertThat(PythonVersionUtils.fromString("==3.11.4")).containsExactly(V_311);
+    assertThat(PythonVersionUtils.fromString("!=3.11")).containsExactly(V_38, V_39, V_310, V_312, V_313, V_314);
+    assertThat(PythonVersionUtils.fromString(">=3,!=3.11")).containsExactly(V_38, V_39, V_310, V_312, V_313, V_314);
+    assertThat(PythonVersionUtils.fromString(">=3,!=3.11.*")).containsExactly(V_38, V_39, V_310, V_312, V_313, V_314);
+  }
+
+  @Test
+  void compatible_and_poetry_specifiers() {
+    assertThat(PythonVersionUtils.fromString("~=3.10")).containsExactly(V_310, V_311, V_312, V_313, V_314);
+    assertThat(PythonVersionUtils.fromString("~=3.10.1")).containsExactly(V_310);
+    assertThat(PythonVersionUtils.fromString("^3.10")).containsExactly(V_310, V_311, V_312, V_313, V_314);
+    assertThat(PythonVersionUtils.fromString("^3.10.1")).containsExactly(V_310, V_311, V_312, V_313, V_314);
+  }
+
+  @Test
+  void ranges_without_supported_versions_fall_back_to_all_versions() {
+    assertThat(PythonVersionUtils.fromString(">=3.15")).hasSameElementsAs(allVersions);
+    assertThat(logTester.logs(Level.WARN))
+      .contains("No supported Python version matches version range >=3.15. Analysis will target all supported Python versions.");
+
+    assertThat(PythonVersionUtils.fromString(">=3,<3.8")).hasSameElementsAs(allVersions);
+    assertThat(logTester.logs(Level.WARN))
+      .contains("No supported Python version matches version range >=3,<3.8. Analysis will target all supported Python versions.");
+  }
+
+  @Test
+  void contradictory_or_unsupported_ranges_fall_back_to_all_versions() {
+    assertThat(PythonVersionUtils.fromString(">=3.12,<3.11")).hasSameElementsAs(allVersions);
+    assertThat(logTester.logs(Level.WARN))
+      .contains("No supported Python version matches version range >=3.12,<3.11. Analysis will target all supported Python versions.");
+
+    assertThat(PythonVersionUtils.fromString("<3")).hasSameElementsAs(allVersions);
+    assertThat(logTester.logs(Level.WARN))
+      .contains("No supported Python version matches version range <3. Analysis will target all supported Python versions.");
+  }
+
+  @ParameterizedTest
+  @ValueSource(strings = {"3.10,>=3.11", "~=3", "~3.10", "===3.10", ">=3.10rc1", "^3.10 || ^3.11", ">=3.10.*", "==foo"})
+  void unsupported_range_syntax(String value) {
+    assertThat(PythonVersionUtils.fromString(value)).hasSameElementsAs(allVersions);
+    assertThat(logTester.logs(Level.WARN))
+      .contains("Error while parsing value of parameter 'sonar.python.version' (" + value
+        + "). Use comma-separated Python versions (e.g. \"3.10,3.11\") or numeric version specifiers (e.g. \">=3.10,<3.13\").");
+  }
+
   @Test
   void error_while_parsing_version() {
     assertThat(PythonVersionUtils.fromString("foo")).hasSameElementsAs(allVersions);
     assertThat(logTester.logs(Level.WARN))
-      .contains("Error while parsing value of parameter 'sonar.python.version' (foo). Versions must be specified as MAJOR_VERSION.MINOR_VERSION (e.g. \"3.7, 3.8\")");
+      .contains("Error while parsing value of parameter 'sonar.python.version' (foo). Use comma-separated Python versions (e.g. \"3.10,3.11\") or numeric version specifiers (e.g. \">=3.10,<3.13\").");
   }
 
   @Test
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonVisitorContextTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonVisitorContextTest.java
index 790411200e..7596a4fcf5 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonVisitorContextTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/PythonVisitorContextTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,7 +21,6 @@
 import java.util.Map;
 import java.util.Set;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.api.SonarProduct;
 import org.sonar.plugins.python.api.symbols.Symbol;
 import org.sonar.plugins.python.api.tree.FileInput;
@@ -29,6 +28,7 @@
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.python.PythonTestUtils;
 import org.sonar.python.caching.CacheContextImpl;
+import org.sonar.python.cfg.fixpoint.LiveVariablesAnalysis;
 import org.sonar.python.index.Descriptor;
 import org.sonar.python.index.VariableDescriptor;
 import org.sonar.python.parser.PythonParser;
@@ -41,9 +41,53 @@
 
 import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 import static org.sonar.python.PythonTestUtils.pythonFile;
 
 class PythonVisitorContextTest {
+  @Test
+  void likely_test_file_is_provided_by_the_scanner() {
+    var fileInput = PythonTestUtils.parse("import pytest");
+    var context = new PythonVisitorContext.Builder(fileInput, pythonFile("production.py"))
+      .likelyTestFile(true)
+      .build();
+
+    assertThat(context.isLikelyTestFile()).isTrue();
+  }
+
+  @Test
+  void likely_test_file_uses_python_ast_signals_when_not_set_by_the_scanner() {
+    var fileInput = PythonTestUtils.parse("import pytest");
+    var context = new PythonVisitorContext.Builder(fileInput, pythonFile("production.py")).build();
+
+    assertThat(context.isLikelyTestFile()).isTrue();
+  }
+
+  @Test
+  void likely_test_file_is_available_after_a_parse_error() {
+    RecognitionException parsingException = mock(RecognitionException.class);
+    var context = new PythonVisitorContext(pythonFile("production.py"), parsingException, SonarProduct.SONARQUBE, true);
+
+    assertThat(context.isLikelyTestFile()).isTrue();
+  }
+
+  @Test
+  void likely_test_file_is_false_for_parse_error_context_without_a_classification() {
+    RecognitionException parsingException = mock(RecognitionException.class);
+    var context = new PythonVisitorContext(null, parsingException, SonarProduct.SONARQUBE);
+
+    assertThat(context.isLikelyTestFile()).isFalse();
+  }
+
+  @Test
+  void likely_test_file_can_be_set_to_false() {
+    var context = new PythonVisitorContext.Builder(PythonTestUtils.parse("import pytest"), pythonFile("production.py"))
+      .likelyTestFile(false)
+      .build();
+
+    assertThat(context.isLikelyTestFile()).isFalse();
+  }
+
   @Test
   void fullyQualifiedModuleName() {
     FileInput fileInput = PythonTestUtils.parse("def foo(): pass");
@@ -62,7 +106,7 @@ void fullyQualifiedModuleName() {
       .hasFieldOrPropertyWithValue("fullyQualifiedName", "my_module");
 
     // file without extension
-    Mockito.when(pythonFile.fileName()).thenReturn("my_module");
+    when(pythonFile.fileName()).thenReturn("my_module");
     ctx = new PythonVisitorContext.Builder(fileInput, pythonFile).packageName("my_package").build();
     functionDef = (FunctionDef) PythonTestUtils.getAllDescendant(fileInput, t -> t.is(Tree.Kind.FUNCDEF)).get(0);
     assertThat(functionDef.name().symbol().fullyQualifiedName()).isEqualTo("my_package.my_module.foo");
@@ -125,6 +169,40 @@ def foo():
 
   }
 
+  @Test
+  void lva_returns_null_when_no_cfg() {
+    FileInput fileInput = PythonTestUtils.parse("def foo():\n  x = 1");
+    PythonFile pythonFile = pythonFile("my_module.py");
+    var ctx = new PythonVisitorContext.Builder(fileInput, pythonFile).build();
+
+    FunctionDef functionDef = (FunctionDef) PythonTestUtils.getAllDescendant(fileInput, t -> t.is(Tree.Kind.FUNCDEF)).get(0);
+    // A Name node has no CFG entry, so lva should return null
+    assertThat(ctx.lva(functionDef.name())).isNull();
+  }
+
+  @Test
+  void lva_returns_analysis_for_function_def() {
+    FileInput fileInput = PythonTestUtils.parse("def foo():\n  x = 1\n  return x");
+    PythonFile pythonFile = pythonFile("my_module.py");
+    var ctx = new PythonVisitorContext.Builder(fileInput, pythonFile).build();
+
+    FunctionDef functionDef = (FunctionDef) PythonTestUtils.getAllDescendant(fileInput, t -> t.is(Tree.Kind.FUNCDEF)).get(0);
+    LiveVariablesAnalysis lva = ctx.lva(functionDef);
+    assertThat(lva).isNotNull();
+  }
+
+  @Test
+  void lva_caches_result() {
+    FileInput fileInput = PythonTestUtils.parse("def foo():\n  x = 1\n  return x");
+    PythonFile pythonFile = pythonFile("my_module.py");
+    var ctx = new PythonVisitorContext.Builder(fileInput, pythonFile).build();
+
+    FunctionDef functionDef = (FunctionDef) PythonTestUtils.getAllDescendant(fileInput, t -> t.is(Tree.Kind.FUNCDEF)).get(0);
+    LiveVariablesAnalysis first = ctx.lva(functionDef);
+    LiveVariablesAnalysis second = ctx.lva(functionDef);
+    assertThat(first).isSameAs(second);
+  }
+
   @Test
   void sonar_product() {
     CacheContextImpl cacheContext = CacheContextImpl.dummyCache();
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/SonarLintCacheTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/SonarLintCacheTest.java
index 1afe09420a..22e8997ee1 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/SonarLintCacheTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/SonarLintCacheTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,10 +20,11 @@
 import java.io.IOException;
 import java.io.InputStream;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 
 import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
 import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class SonarLintCacheTest {
 
@@ -60,8 +61,8 @@ void contains() {
 
   @Test
   void write_non_valid_input_stream() throws IOException {
-    InputStream inputStream = Mockito.mock(InputStream.class);
-    Mockito.when(inputStream.readAllBytes()).thenThrow(IOException.class);
+    InputStream inputStream = mock(InputStream.class);
+    when(inputStream.readAllBytes()).thenThrow(IOException.class);
 
     SonarLintCache sonarLintCache = new SonarLintCache();
     assertThatThrownBy(() -> sonarLintCache.write("foo", inputStream)).isInstanceOf(IllegalStateException.class).hasCauseInstanceOf(IOException.class);
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/SonarLintCacheWrapperTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/SonarLintCacheWrapperTest.java
index ad99fbbca0..53ab4b29b5 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/SonarLintCacheWrapperTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/SonarLintCacheWrapperTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/SubscriptionContextTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/SubscriptionContextTest.java
new file mode 100644
index 0000000000..1c8c8ec6a3
--- /dev/null
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/SubscriptionContextTest.java
@@ -0,0 +1,151 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.api;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.Set;
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.caching.CacheContext;
+import org.sonar.plugins.python.api.cfg.ControlFlowGraph;
+import org.sonar.plugins.python.api.project.configuration.ProjectConfiguration;
+import org.sonar.plugins.python.api.symbols.Symbol;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.Token;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.python.cfg.fixpoint.LiveVariablesAnalysis;
+import org.sonar.python.semantic.v2.callgraph.CallGraph;
+import org.sonar.python.semantic.v2.typetable.TypeTable;
+import org.sonar.python.types.v2.TypeChecker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SubscriptionContextTest {
+
+  @Test
+  void is_likely_test_file_defaults_to_false_for_external_implementations() {
+    // A SubscriptionContext implemented outside the analyzer that predates isLikelyTestFile()
+    // must keep compiling; the default implementation answers false.
+    SubscriptionContext context = new MinimalSubscriptionContext();
+
+    assertThat(context.isLikelyTestFile()).isFalse();
+  }
+
+  private static class MinimalSubscriptionContext implements SubscriptionContext {
+    @Override
+    public Tree syntaxNode() {
+      return null;
+    }
+
+    @Override
+    public PythonCheck.PreciseIssue addIssue(Tree element, String message) {
+      return null;
+    }
+
+    @Override
+    public PythonCheck.PreciseIssue addIssue(LocationInFile location, String message) {
+      return null;
+    }
+
+    @Override
+    public PythonCheck.PreciseIssue addIssue(Token token, String message) {
+      return null;
+    }
+
+    @Override
+    public PythonCheck.PreciseIssue addIssue(Token from, Token to, String message) {
+      return null;
+    }
+
+    @Override
+    public PythonCheck.PreciseIssue addFileIssue(String finalMessage) {
+      return null;
+    }
+
+    @Override
+    public PythonCheck.PreciseIssue addLineIssue(String message, int lineNumber) {
+      return null;
+    }
+
+    @Override
+    public PythonFile pythonFile() {
+      return null;
+    }
+
+    @Override
+    public Set sourcePythonVersions() {
+      return null;
+    }
+
+    @Override
+    public Collection stubFilesSymbols() {
+      return null;
+    }
+
+    @Override
+    public File workingDirectory() {
+      return null;
+    }
+
+    @Override
+    public CacheContext cacheContext() {
+      return null;
+    }
+
+    @Override
+    public TypeChecker typeChecker() {
+      return null;
+    }
+
+    @Override
+    public TypeTable typeTable() {
+      return null;
+    }
+
+    @Override
+    public ProjectConfiguration projectConfiguration() {
+      return null;
+    }
+
+    @Override
+    public CallGraph callGraph() {
+      return null;
+    }
+
+    @Override
+    public ControlFlowGraph cfg(Tree tree) {
+      return null;
+    }
+
+    @Override
+    public LiveVariablesAnalysis lva(Tree tree) {
+      return null;
+    }
+
+    @Override
+    public Set valuesAtLocation(Name name) {
+      return null;
+    }
+
+    @Override
+    public Optional getDjangoViewInfo(String fqn) {
+      return Optional.empty();
+    }
+  }
+}
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/CfgValidator.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/CfgValidator.java
index 857e983400..9836827e68 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/CfgValidator.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/CfgValidator.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/ControlFlowGraphTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/ControlFlowGraphTest.java
index 35195c7db6..d284568a14 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/ControlFlowGraphTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/ControlFlowGraphTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,7 +20,6 @@
 import java.util.List;
 import java.util.stream.Collectors;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.tree.ExpressionStatement;
 import org.sonar.plugins.python.api.tree.FileInput;
@@ -35,10 +34,11 @@
 import org.sonar.python.cfg.PythonCfgSimpleBlock;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 class ControlFlowGraphTest {
 
-  private PythonFile file = Mockito.mock(PythonFile.class, "file1.py");
+  private PythonFile file = mock(PythonFile.class, "file1.py");
 
   @Test
   void empty_file() {
@@ -632,6 +632,219 @@ void match_statement() {
     assertThat(secondCaseFalseSuccessor).isEqualTo(barBlock);
   }
 
+  @Test
+  void match_statement_irrefutable_in_middle() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case _: z()",
+      "  case \"b\": w()",
+      "bar()"
+    );
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    PythonCfgEndBlock end = (PythonCfgEndBlock) cfg.end();
+    assertThat(end.predecessors()).hasSize(1);
+    CfgBlock barBlock = end.predecessors().stream().findFirst().get();
+
+    // Start block evaluates case "a" (first refutable case before irrefutable)
+    assertThat(start.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.EXPRESSION_STMT, Kind.NAME, Kind.STRING_LITERAL_PATTERN);
+
+    // case "a" body flows to bar
+    PythonCfgSimpleBlock caseABody = (PythonCfgSimpleBlock) start.trueSuccessor();
+    assertThat(caseABody.elements()).extracting(Tree::getKind).containsExactly(Kind.EXPRESSION_STMT);
+    assertThat(caseABody.successors()).containsExactly(barBlock);
+
+    // case "a" false successor is the irrefutable block (case _), not case "b"
+    PythonCfgSimpleBlock irrefutableBlock = (PythonCfgSimpleBlock) start.falseSuccessor();
+    assertThat(irrefutableBlock.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.NAME, Kind.WILDCARD_PATTERN);
+
+    // irrefutable body flows to bar
+    CfgBlock irrefutableBody = irrefutableBlock.successors().stream().findFirst().get();
+    assertThat(irrefutableBody.elements()).extracting(Tree::getKind).containsExactly(Kind.EXPRESSION_STMT);
+    assertThat(irrefutableBody.successors()).containsExactly(barBlock);
+  }
+
+  @Test
+  void match_statement_irrefutable_last() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case _: z()",
+      "bar()"
+    );
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    PythonCfgEndBlock end = (PythonCfgEndBlock) cfg.end();
+    assertThat(end.predecessors()).hasSize(1);
+    CfgBlock barBlock = end.predecessors().stream().findFirst().get();
+
+    // case "a" is the only pre-irrefutable case
+    assertThat(start.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.EXPRESSION_STMT, Kind.NAME, Kind.STRING_LITERAL_PATTERN);
+
+    PythonCfgSimpleBlock caseABody = (PythonCfgSimpleBlock) start.trueSuccessor();
+    assertThat(caseABody.successors()).containsExactly(barBlock);
+
+    // case "a" false successor is the irrefutable block (case _), not the post-match successor
+    PythonCfgSimpleBlock irrefutableBlock = (PythonCfgSimpleBlock) start.falseSuccessor();
+    assertThat(irrefutableBlock.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.NAME, Kind.WILDCARD_PATTERN);
+
+    CfgBlock irrefutableBody = irrefutableBlock.successors().stream().findFirst().get();
+    assertThat(irrefutableBody.successors()).containsExactly(barBlock);
+  }
+
+  @Test
+  void match_statement_irrefutable_first() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case _: y()",
+      "  case \"a\": z()",
+      "bar()"
+    );
+
+    // When the irrefutable case is first, the CFG start is a simple block (no branching needed)
+    PythonCfgSimpleBlock start = (PythonCfgSimpleBlock) cfg.start();
+    PythonCfgEndBlock end = (PythonCfgEndBlock) cfg.end();
+    assertThat(end.predecessors()).hasSize(1);
+    CfgBlock barBlock = end.predecessors().stream().findFirst().get();
+
+    // The start block is the irrefutable block; subsequent unreachable cases are excluded from the CFG
+    assertThat(start.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.EXPRESSION_STMT, Kind.NAME, Kind.WILDCARD_PATTERN);
+
+    CfgBlock irrefutableBody = start.successors().stream().findFirst().get();
+    assertThat(irrefutableBody.elements()).extracting(Tree::getKind).containsExactly(Kind.EXPRESSION_STMT);
+    assertThat(irrefutableBody.successors()).containsExactly(barBlock);
+  }
+
+  @Test
+  void match_statement_guarded_wildcard_is_refutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case _ if w(): z()",
+      "bar()"
+    );
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    PythonCfgEndBlock end = (PythonCfgEndBlock) cfg.end();
+    assertThat(end.predecessors()).hasSize(1);
+    CfgBlock barBlock = end.predecessors().stream().findFirst().get();
+
+    assertThat(start.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.EXPRESSION_STMT, Kind.NAME, Kind.STRING_LITERAL_PATTERN);
+
+    PythonCfgSimpleBlock caseABody = (PythonCfgSimpleBlock) start.trueSuccessor();
+    assertThat(caseABody.successors()).containsExactly(barBlock);
+
+    // A guarded wildcard is refutable: it still has a false successor (the no-match path)
+    PythonCfgBranchingBlock guardedWildcard = (PythonCfgBranchingBlock) start.falseSuccessor();
+    assertThat(guardedWildcard.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.NAME, Kind.WILDCARD_PATTERN, Kind.CALL_EXPR);
+    assertThat(guardedWildcard.falseSuccessor()).isEqualTo(barBlock);
+  }
+
+  @Test
+  void match_statement_group_pattern_is_irrefutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case (z): w()",
+      "bar()"
+    );
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    PythonCfgEndBlock end = (PythonCfgEndBlock) cfg.end();
+    assertThat(end.predecessors()).hasSize(1);
+    CfgBlock barBlock = end.predecessors().stream().findFirst().get();
+
+    // case "a" false successor must be the irrefutable block (case (z)), not barBlock
+    PythonCfgSimpleBlock irrefutableBlock = (PythonCfgSimpleBlock) start.falseSuccessor();
+    assertThat(irrefutableBlock.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.NAME, Kind.GROUP_PATTERN);
+
+    CfgBlock irrefutableBody = irrefutableBlock.successors().stream().findFirst().get();
+    assertThat(irrefutableBody.successors()).containsExactly(barBlock);
+  }
+
+  @Test
+  void match_statement_group_wildcard_pattern_is_irrefutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case (_): w()",
+      "bar()"
+    );
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    // case "a" false successor must be a simple block (irrefutable), not a branching block
+    PythonCfgSimpleBlock irrefutableBlock = (PythonCfgSimpleBlock) start.falseSuccessor();
+    assertThat(irrefutableBlock.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.NAME, Kind.GROUP_PATTERN);
+  }
+
+  @Test
+  void match_statement_nested_group_pattern_is_irrefutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case ((z)): w()",
+      "bar()"
+    );
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    // case "a" false successor must be a simple block (irrefutable), not a branching block
+    PythonCfgSimpleBlock irrefutableBlock = (PythonCfgSimpleBlock) start.falseSuccessor();
+    assertThat(irrefutableBlock.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.NAME, Kind.GROUP_PATTERN);
+  }
+
+  @Test
+  void match_statement_group_literal_pattern_is_refutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case (42): w()",
+      "bar()"
+    );
+
+    // Both cases are refutable — the second case must be a branching block
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    PythonCfgBranchingBlock secondCase = (PythonCfgBranchingBlock) start.falseSuccessor();
+    assertThat(secondCase).isInstanceOf(PythonCfgBranchingBlock.class);
+    // The false path of the second case leads directly to barBlock (no-match path)
+    PythonCfgEndBlock end = (PythonCfgEndBlock) cfg.end();
+    CfgBlock barBlock = end.predecessors().stream().findFirst().get();
+    assertThat(secondCase.falseSuccessor()).isEqualTo(barBlock);
+  }
+
+  @Test
+  void match_statement_guarded_group_pattern_is_refutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case (z) if w(): v()",
+      "bar()"
+    );
+
+    // Both cases are refutable — the second case must be a branching block
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    assertThat(start.falseSuccessor()).isInstanceOf(PythonCfgBranchingBlock.class);
+  }
+
   @Test
   void CFGBlock_toString() {
     PythonCfgEndBlock endBlock = new PythonCfgEndBlock();
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/ExpectedCfgStructure.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/ExpectedCfgStructure.java
index 962466b484..b818c83f73 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/ExpectedCfgStructure.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/ExpectedCfgStructure.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/nosonar/NoSonarInfoParserTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/nosonar/NoSonarInfoParserTest.java
index 561681555f..2482bbc272 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/nosonar/NoSonarInfoParserTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/nosonar/NoSonarInfoParserTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -45,6 +45,10 @@ void parsingTest(String commentString, NoSonarLineInfo expectedLineInfo) {
   }
 
   private static Stream provideParserParameters() {
+    return Stream.concat(provideNoSonarAndNoQaParserParameters(), provideNoSecParserParameters());
+  }
+
+  private static Stream provideNoSonarAndNoQaParserParameters() {
     return Stream.of(
       Arguments.of(
         "# NOSONAR(something)",
@@ -134,6 +138,67 @@ private static Stream provideParserParameters() {
     );
   }
 
+  private static Stream provideNoSecParserParameters() {
+    return Stream.of(
+      // bare nosec → security-only suppression (no explicit keys)
+      Arguments.of(
+        "# nosec",
+        NoSonarLineInfo.securityOnly()
+      ),
+      // nosec with explicit bandit key
+      Arguments.of(
+        "# nosec B101",
+        new NoSonarLineInfo(Set.of("B101"))
+      ),
+      Arguments.of(
+        "# nosec B101, B102 reason text",
+        new NoSonarLineInfo(Set.of("B101", "B102"))
+      ),
+      // nosec with explicit Sonar key
+      Arguments.of(
+        "# nosec S1234",
+        new NoSonarLineInfo(Set.of("S1234"))
+      ),
+      Arguments.of(
+        "# nosec S1234, S5678",
+        new NoSonarLineInfo(Set.of("S1234", "S5678"))
+      ),
+      Arguments.of(
+        "# nosec: S1234, S5678 reason text",
+        new NoSonarLineInfo(Set.of("S1234", "S5678"))
+      ),
+      Arguments.of(
+        "# nosec B303, S1234",
+        new NoSonarLineInfo(Set.of("B303", "S1234"))
+      ),
+      // bare nosec with free-text reason → security-only suppression
+      Arguments.of(
+        "# nosec: it's fine",
+        NoSonarLineInfo.securityOnly("it's fine")
+      ),
+      // case-insensitive bare nosec
+      Arguments.of(
+        "# NOSEC",
+        NoSonarLineInfo.securityOnly()
+      ),
+      // bare nosec with long reason → truncated comment, security-only
+      Arguments.of(
+        "# nosec a very long comment that I don't want to keep that long because there is more than 50 characters",
+        NoSonarLineInfo.securityOnly("a very long comment that I don't want to keep that")
+      ),
+      // non-suppression text before bare nosec → comment captured, security-only
+      Arguments.of(
+        "# some text # nosec",
+        NoSonarLineInfo.securityOnly("# some text")
+      ),
+      // mixed: explicit rule key from noqa + bare nosec → explicit key suppressed, security rules also suppressed
+      Arguments.of(
+        "# noqa: E501 # nosec",
+        new NoSonarLineInfo(Set.of("E501"), "", true)
+      )
+    );
+  }
+
   @ParameterizedTest
   @MethodSource("provideValidationParameters")
   void validationTest(String commentString, boolean expectedIsInvalid) {
@@ -187,7 +252,19 @@ private static Stream provideValidationParameters() {
       Arguments.of("#NOSONAR(S3)", false),
       Arguments.of("#NOSONAR(python:S3723)", true),
       Arguments.of("#NOSONAR(S-123)", true),
-      Arguments.of("#NOSONAR(NoSonar)", false)
+      Arguments.of("#NOSONAR(NoSonar)", false),
+
+      Arguments.of("# nosec", false),
+      Arguments.of("# nosec B101", false),
+      Arguments.of("# nosec B101, B102", false),
+      Arguments.of("# nosec B101, B102 reason text", false),
+      Arguments.of("# nosec: S1234, S5678", false),
+      Arguments.of("# nosec because of foo, bar, and baz", false),
+      Arguments.of("# nosec B101,", true),
+      Arguments.of("# nosec ,B101", true),
+      Arguments.of("# nosec B101,,B102", true),
+      Arguments.of("# nosec B101, foo", true),
+      Arguments.of("# nosec B101 reason, B102", true)
     );
   }
 
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/nosonar/NoSonarLineInfoTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/nosonar/NoSonarLineInfoTest.java
index dd5dc8cf99..790c2d89c0 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/nosonar/NoSonarLineInfoTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/nosonar/NoSonarLineInfoTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/quickfix/PythonQuickFixTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/quickfix/PythonQuickFixTest.java
index 67972ef755..81fe71a356 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/quickfix/PythonQuickFixTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/quickfix/PythonQuickFixTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/quickfix/PythonTextEditTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/quickfix/PythonTextEditTest.java
index f2a8cf5351..9a13f11a3f 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/quickfix/PythonTextEditTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/quickfix/PythonTextEditTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/tree/BaseTreeVisitorTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/tree/BaseTreeVisitorTest.java
index b4742b1099..d4d1951bf1 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/tree/BaseTreeVisitorTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/tree/BaseTreeVisitorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ClassTypeTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ClassTypeTest.java
index f4b741164b..eb00966413 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ClassTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ClassTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -26,7 +26,6 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.LocationInFile;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.TriBool;
@@ -53,6 +52,7 @@
 import static org.sonar.python.PythonTestUtils.pythonFile;
 import static org.sonar.python.semantic.ProjectLevelSymbolTable.empty;
 import static org.sonar.python.types.v2.TypesTestUtils.PROJECT_LEVEL_TYPE_TABLE;
+import static org.mockito.Mockito.mock;
 
 public class ClassTypeTest {
 
@@ -98,7 +98,7 @@ def foo(): ...
 
   @Test
   void members() {
-    FunctionType barMember = Mockito.mock(FunctionType.class);
+    FunctionType barMember = mock(FunctionType.class);
     Member bar = new Member("bar", barMember);
     Member qix = new Member("qix", PythonType.UNKNOWN);
     ClassType classType = new ClassType(
@@ -869,6 +869,216 @@ void type_annotations_scope() {
   }
 
 
+  // -------------------------------------------------------------------------
+  // mro() tests
+  // -------------------------------------------------------------------------
+
+  @Test
+  void mro_no_parents() {
+    ClassType classC = classType("class C: ...");
+    assertThat(classC.mro()).isPresent().get().asInstanceOf(
+      org.assertj.core.api.InstanceOfAssertFactories.list(ClassType.class))
+      .containsExactly(classC);
+  }
+
+  @Test
+  void mro_single_parent() {
+    List types = classTypes(
+      "class Base: ...",
+      "class Child(Base): ..."
+    );
+    ClassType base = types.get(0);
+    ClassType child = types.get(1);
+    assertThat(child.mro()).isPresent().get().asInstanceOf(
+      org.assertj.core.api.InstanceOfAssertFactories.list(ClassType.class))
+      .containsExactly(child, base);
+  }
+
+  @Test
+  void mro_linear_chain() {
+    List types = classTypes(
+      "class A: ...",
+      "class B(A): ...",
+      "class C(B): ..."
+    );
+    ClassType a = types.get(0);
+    ClassType b = types.get(1);
+    ClassType c = types.get(2);
+    assertThat(c.mro()).isPresent().get().asInstanceOf(
+      org.assertj.core.api.InstanceOfAssertFactories.list(ClassType.class))
+      .containsExactly(c, b, a);
+  }
+
+  @Test
+  void mro_valid_diamond() {
+    // Classic diamond: D(B, C), B(A), C(A)
+    // MRO: D, B, C, A
+    List types = classTypes(
+      "class A: ...",
+      "class B(A): ...",
+      "class C(A): ...",
+      "class D(B, C): ..."
+    );
+    ClassType a = types.get(0);
+    ClassType b = types.get(1);
+    ClassType c = types.get(2);
+    ClassType d = types.get(3);
+    assertThat(d.mro()).isPresent().get().asInstanceOf(
+      org.assertj.core.api.InstanceOfAssertFactories.list(ClassType.class))
+      .containsExactly(d, b, c, a);
+  }
+
+  @Test
+  void mro_conflict_returns_empty() {
+    // class Leaf(Base): ...
+    // class Broken(Base, Leaf): ...  <- MRO conflict
+    List types = classTypes(
+      "class Base: ...",
+      "class Leaf(Base): ...",
+      "class Broken(Base, Leaf): ..."
+    );
+    ClassType broken = types.get(2);
+    assertThat(broken.mro()).isEmpty();
+  }
+
+  @Test
+  void wouldHaveValidMro_returns_false_when_merge_fails() {
+    // Same hierarchy as mro_conflict_returns_empty: merging Base with Leaf (Leaf extends Base) fails.
+    List types = classTypes(
+      "class Base: ...",
+      "class Leaf(Base): ...",
+      "class Broken(Base, Leaf): ..."
+    );
+    ClassType base = types.get(0);
+    ClassType leaf = types.get(1);
+    assertThat(ClassType.wouldHaveValidMro(List.of(base, leaf))).isFalse();
+  }
+
+  @Test
+  void wouldHaveValidMro_returns_true_for_diamond_inheritance_bases() {
+    List types = classTypes(
+      "class A: ...",
+      "class B(A): ...",
+      "class C(A): ...",
+      "class D(B, C): ..."
+    );
+    ClassType b = types.get(1);
+    ClassType c = types.get(2);
+    assertThat(ClassType.wouldHaveValidMro(List.of(b, c))).isTrue();
+  }
+
+  @Test
+  void wouldHaveValidMro_ignores_typeshed_virtual_abc_inheritance_for_dict() {
+    // typeshed declares `class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT])`, but at runtime
+    // dict only inherits from `object` and the MutableMapping relationship is a virtual-subclass
+    // registration via `abc.ABCMeta.register()`. C3 succeeds at runtime for class N(MutableMapping, dict).
+    List types = classTypes(
+      "from collections.abc import MutableMapping",
+      "class Holder(MutableMapping, dict): ..."
+    );
+    ClassType holder = types.get(0);
+    assertThat(holder.superClasses()).hasSize(2);
+    var bases = holder.superClasses().stream()
+      .map(sw -> (ClassType) sw.type())
+      .toList();
+    assertThat(ClassType.wouldHaveValidMro(bases)).isTrue();
+  }
+
+  @Test
+  void wouldHaveValidMro_handles_user_subclass_of_builtin_container() {
+    // class MyDict(dict): ...; class X(MutableMapping, MyDict): ... is valid at runtime because
+    // MyDict's runtime MRO is [MyDict, dict, object] (no MutableMapping) — the typeshed link from
+    // dict to MutableMapping is fictional.
+    List types = classTypes(
+      "from collections.abc import MutableMapping",
+      "class MyDict(dict): ...",
+      "class X(MutableMapping, MyDict): ..."
+    );
+    ClassType x = types.get(1);
+    var bases = x.superClasses().stream()
+      .map(sw -> (ClassType) sw.type())
+      .toList();
+    assertThat(ClassType.wouldHaveValidMro(bases)).isTrue();
+  }
+
+  @Test
+  void wouldHaveValidMro_still_detects_real_conflict_with_builtin_container() {
+    // class MyDict(dict): ...; class X(dict, MyDict): ... is rejected at runtime because dict
+    // appears before its own subclass.
+    List types = classTypes(
+      "class MyDict(dict): ...",
+      "class X(dict, MyDict): ..."
+    );
+    ClassType x = types.get(1);
+    var bases = x.superClasses().stream()
+      .map(sw -> (ClassType) sw.type())
+      .toList();
+    assertThat(ClassType.wouldHaveValidMro(bases)).isFalse();
+  }
+
+  @Test
+  void wouldHaveValidMro_rejects_object_before_builtin_container() {
+    // class X(object, dict): ... is rejected at runtime ("Cannot create a consistent MRO …") because
+    // dict.__mro__ ends with object, so object must come after dict. The runtime-view MRO must keep
+    // the object tail to catch this — otherwise stripping dict's typeshed parents to just [dict]
+    // would let the merge succeed (false negative).
+    var objectType = (ClassType) PROJECT_LEVEL_TYPE_TABLE.getType("object");
+    var dictType = (ClassType) PROJECT_LEVEL_TYPE_TABLE.getType("dict");
+    assertThat(ClassType.wouldHaveValidMro(List.of(objectType, dictType))).isFalse();
+    assertThat(ClassType.wouldHaveValidMro(List.of(dictType, objectType))).isTrue();
+  }
+
+  @Test
+  void mro_unresolved_hierarchy_returns_empty() {
+    // class Child(Unknown): ...  <- unresolved parent
+    List types = classTypes(
+      "class Child(Unknown): ..."
+    );
+    ClassType child = types.get(0);
+    assertThat(child.mro()).isEmpty();
+  }
+
+  @Test
+  void mro_with_builtin_parent() {
+    List types = classTypes(
+      "class MyError(BaseException): ..."
+    );
+    ClassType myError = types.get(0);
+    var mro = myError.mro();
+    assertThat(mro).isPresent();
+    assertThat(mro.get().get(0)).isSameAs(myError);
+    assertThat(mro.get().stream().map(ClassType::name)).contains("BaseException");
+  }
+
+  @Test
+  void mro_c3_ordering() {
+    // From https://docs.python.org/3/howto/mro.html
+    // class F: ...
+    // class E: ...
+    // class D: ...
+    // class C(D, F): ...
+    // class B(D, E): ...
+    // class A(B, C): ...
+    // MRO(A) = A, B, C, D, E, F
+    List types = classTypes(
+      "class F: ...",
+      "class E: ...",
+      "class D: ...",
+      "class C(D, F): ...",
+      "class B(D, E): ...",
+      "class A(B, C): ..."
+    );
+    ClassType f = types.get(0);
+    ClassType e = types.get(1);
+    ClassType d = types.get(2);
+    ClassType c = types.get(3);
+    ClassType b = types.get(4);
+    ClassType a = types.get(5);
+    assertThat(a.mro()).isPresent().get().asInstanceOf(
+      org.assertj.core.api.InstanceOfAssertFactories.list(ClassType.class))
+      .containsExactly(a, b, c, d, e, f);
+  }
+
   @Test
   void builder() {
     ClassTypeBuilder classTypeBuilder = new ClassTypeBuilder("A", "mod.A");
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/FullyQualifiedNameHelperTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/FullyQualifiedNameHelperTest.java
index 4b5e2ff320..6aa6170a1f 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/FullyQualifiedNameHelperTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/FullyQualifiedNameHelperTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,29 +17,30 @@
 package org.sonar.plugins.python.api.types.v2;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.python.types.v2.SpecialFormType;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class FullyQualifiedNameHelperTest {
   
   @Test
   void testGetFullyQualifiedName() {
-    FunctionType function1 = Mockito.mock(FunctionType.class);
-    FunctionType nullFunctionType = Mockito.mock(FunctionType.class);
-    ClassType class1 = Mockito.mock(ClassType.class);
-    UnknownType.UnresolvedImportType unresolvedImport = Mockito.mock(UnknownType.UnresolvedImportType.class);
-    ModuleType module1 = Mockito.mock(ModuleType.class);
-    SpecialFormType specialFormType1 = Mockito.mock(SpecialFormType.class);
-    UnknownType.UnknownTypeImpl unknownType = Mockito.mock(UnknownType.UnknownTypeImpl.class);
+    FunctionType function1 = mock(FunctionType.class);
+    FunctionType nullFunctionType = mock(FunctionType.class);
+    ClassType class1 = mock(ClassType.class);
+    UnknownType.UnresolvedImportType unresolvedImport = mock(UnknownType.UnresolvedImportType.class);
+    ModuleType module1 = mock(ModuleType.class);
+    SpecialFormType specialFormType1 = mock(SpecialFormType.class);
+    UnknownType.UnknownTypeImpl unknownType = mock(UnknownType.UnknownTypeImpl.class);
 
-    Mockito.when(function1.fullyQualifiedName()).thenReturn("foo.bar.func1");
-    Mockito.when(nullFunctionType.fullyQualifiedName()).thenReturn(null);
-    Mockito.when(class1.fullyQualifiedName()).thenReturn("foo.bar.class1");
-    Mockito.when(module1.fullyQualifiedName()).thenReturn("mod.module1");
-    Mockito.when(specialFormType1.fullyQualifiedName()).thenReturn("typing.List");
-    Mockito.when(unresolvedImport.importPath()).thenReturn("imported.module1");
+    when(function1.fullyQualifiedName()).thenReturn("foo.bar.func1");
+    when(nullFunctionType.fullyQualifiedName()).thenReturn(null);
+    when(class1.fullyQualifiedName()).thenReturn("foo.bar.class1");
+    when(module1.fullyQualifiedName()).thenReturn("mod.module1");
+    when(specialFormType1.fullyQualifiedName()).thenReturn("typing.List");
+    when(unresolvedImport.importPath()).thenReturn("imported.module1");
 
     assertThat(FullyQualifiedNameHelper.getFullyQualifiedName(function1)).contains("foo.bar.func1");
     assertThat(FullyQualifiedNameHelper.getFullyQualifiedName(nullFunctionType)).isEmpty();
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/FunctionTypeTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/FunctionTypeTest.java
index 72d1870b9f..cbfe1f09f3 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/FunctionTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/FunctionTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ModuleTypeTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ModuleTypeTest.java
index ca1a4a1de6..cdee4c7f0e 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ModuleTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ModuleTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ObjectTypeTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ObjectTypeTest.java
index a77eeeec5a..d37ee8a756 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ObjectTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/ObjectTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/SelfTypeTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/SelfTypeTest.java
index 507b803d2c..7f7564e5f3 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/SelfTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/SelfTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/SimpleTypeWrapperTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/SimpleTypeWrapperTest.java
index 8821d9b904..4a1b744b7a 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/SimpleTypeWrapperTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/SimpleTypeWrapperTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/TriBoolTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/TriBoolTest.java
index 8688bbca94..2bae05a555 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/TriBoolTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/TriBoolTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/UnionTypeTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/UnionTypeTest.java
index 01355d8e9b..42cff684b7 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/UnionTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/UnionTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,7 +22,6 @@
 import java.util.Set;
 import org.assertj.core.api.InstanceOfAssertFactories;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.ExpressionStatement;
 import org.sonar.plugins.python.api.tree.FileInput;
@@ -39,6 +38,7 @@
 import static org.sonar.python.types.v2.TypesTestUtils.INT_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.STR_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.parseAndInferTypes;
+import static org.mockito.Mockito.mock;
 
 
 class UnionTypeTest {
@@ -183,7 +183,7 @@ void unionTypeCandidatesResolution() {
 
   @Test
   void noLazyTypeInUnionType() {
-    PythonType lazyType = new LazyType("foo", Mockito.mock(LazyTypesContext.class));
+    PythonType lazyType = new LazyType("foo", mock(LazyTypesContext.class));
     assertThatThrownBy(() -> UnionType.or(INT_TYPE, lazyType))
       .isInstanceOf(IllegalArgumentException.class)
       .hasMessage("UnionType cannot contain Lazy types");
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/UnresolvedImportTypeTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/UnresolvedImportTypeTest.java
index fe002bd486..38de4a1be9 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/UnresolvedImportTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/UnresolvedImportTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/MatchersTestUtils.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/MatchersTestUtils.java
index d7dca7d47f..745e4dc601 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/MatchersTestUtils.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/MatchersTestUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,7 +16,6 @@
  */
 package org.sonar.plugins.python.api.types.v2.matchers;
 
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.python.types.v2.matchers.TypePredicate;
@@ -25,14 +24,16 @@
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public class MatchersTestUtils {
   private MatchersTestUtils() {
   }
 
   public static TypePredicate mockPredicateReturning(PythonType expectedType, TriBool result) {
-    TypePredicate predicate = Mockito.mock(TypePredicate.class);
-    Mockito.when(predicate.check(eq(expectedType), any(TypePredicateContext.class))).thenReturn(result);
+    TypePredicate predicate = mock(TypePredicate.class);
+    when(predicate.check(eq(expectedType), any(TypePredicateContext.class))).thenReturn(result);
     return predicate;
   }
 
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherImplTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherImplTest.java
index 438ebd786d..f8f3a25f79 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,7 +21,6 @@
 import org.jspecify.annotations.NonNull;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.SubscriptionContext;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.Expression;
@@ -38,6 +37,8 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.sonar.plugins.python.api.types.v2.matchers.MatchersTestUtils.createTypeMatcher;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class TypeMatcherImplTest {
 
@@ -53,63 +54,64 @@ public TriBool check(@NonNull PythonType type, @Nullable TypePredicateContext ct
 
   TypeMatcher typeMatcher = createTypeMatcher(isFunctionType);
 
-  PythonType functionType = Mockito.mock(FunctionType.class);
-  PythonType functionType2 = Mockito.mock(FunctionType.class);
-  PythonType objectType = Mockito.mock(ObjectType.class);
-  PythonType objectType2 = Mockito.mock(ObjectType.class);
-  PythonType unknownType = Mockito.mock(UnknownType.UnknownTypeImpl.class);
+  PythonType functionType = mock(FunctionType.class);
+  PythonType functionType2 = mock(FunctionType.class);
+  PythonType objectType = mock(ObjectType.class);
+  PythonType objectType2 = mock(ObjectType.class);
+  PythonType unknownType = mock(UnknownType.UnknownTypeImpl.class);
   PythonType unionWithFunctionAndUnknown = UnionType.or(Set.of(functionType, unknownType));
   PythonType unionWithObjectAndUnknown = UnionType.or(Set.of(objectType, unknownType));
   PythonType unionWithFunctionAndObject = UnionType.or(Set.of(functionType, objectType));
   PythonType unionOfFunctions = UnionType.or(Set.of(functionType, functionType2));
   PythonType unionOfObjects = UnionType.or(Set.of(objectType, objectType2));
 
-  Expression functionExpr = Mockito.mock(Expression.class);
-  Expression unknownExpr = Mockito.mock(Expression.class);
-  Expression objectExpr = Mockito.mock(Expression.class);
-  Expression unionWithFunctionAndUnknownExpr = Mockito.mock(Expression.class);
-  Expression unionWithObjectAndUnknownExpr = Mockito.mock(Expression.class);
-  Expression unionWithFunctionAndObjectExpr = Mockito.mock(Expression.class);
-  Expression unionOfFunctionExpr = Mockito.mock(Expression.class);
-  Expression unionOfObjectExpr = Mockito.mock(Expression.class);
+  Expression functionExpr = mock(Expression.class);
+  Expression unknownExpr = mock(Expression.class);
+  Expression objectExpr = mock(Expression.class);
+  Expression unionWithFunctionAndUnknownExpr = mock(Expression.class);
+  Expression unionWithObjectAndUnknownExpr = mock(Expression.class);
+  Expression unionWithFunctionAndObjectExpr = mock(Expression.class);
+  Expression unionOfFunctionExpr = mock(Expression.class);
+  Expression unionOfObjectExpr = mock(Expression.class);
 
   @BeforeEach
   void prepare() {
-    functionType = Mockito.mock(FunctionType.class);
-    functionType2 = Mockito.mock(FunctionType.class);
-    objectType = Mockito.mock(ObjectType.class);
-    objectType2 = Mockito.mock(ObjectType.class);
-    unknownType = Mockito.mock(UnknownType.UnknownTypeImpl.class);
+    functionType = mock(FunctionType.class);
+    functionType2 = mock(FunctionType.class);
+    objectType = mock(ObjectType.class);
+    objectType2 = mock(ObjectType.class);
+    unknownType = mock(UnknownType.UnknownTypeImpl.class);
     unionWithFunctionAndUnknown = UnionType.or(Set.of(functionType, unknownType));
     unionWithObjectAndUnknown = UnionType.or(Set.of(objectType, unknownType));
     unionWithFunctionAndObject = UnionType.or(Set.of(functionType, objectType));
     unionOfFunctions = UnionType.or(Set.of(functionType, functionType2));
     unionOfObjects = UnionType.or(Set.of(objectType, objectType2));
 
-    functionExpr = Mockito.mock(Expression.class);
-    unknownExpr = Mockito.mock(Expression.class);
-    objectExpr = Mockito.mock(Expression.class);
-    unionWithFunctionAndUnknownExpr = Mockito.mock(Expression.class);
-    unionWithObjectAndUnknownExpr = Mockito.mock(Expression.class);
-    unionWithFunctionAndObjectExpr = Mockito.mock(Expression.class);
-    unionOfFunctionExpr = Mockito.mock(Expression.class);
-    unionOfObjectExpr = Mockito.mock(Expression.class);
-
-
-    Mockito.when(unknownExpr.typeV2()).thenReturn(unknownType);
-    Mockito.when(objectExpr.typeV2()).thenReturn(objectType);
-    Mockito.when(functionExpr.typeV2()).thenReturn(functionType);
-    Mockito.when(unionWithFunctionAndUnknownExpr.typeV2()).thenReturn(unionWithFunctionAndUnknown);
-    Mockito.when(unionWithObjectAndUnknownExpr.typeV2()).thenReturn(unionWithObjectAndUnknown);
-    Mockito.when(unionWithFunctionAndObjectExpr.typeV2()).thenReturn(unionWithFunctionAndObject);
-    Mockito.when(unionOfFunctionExpr.typeV2()).thenReturn(unionOfFunctions);
-    Mockito.when(unionOfObjectExpr.typeV2()).thenReturn(unionOfObjects);
+    functionExpr = mock(Expression.class);
+    unknownExpr = mock(Expression.class);
+    objectExpr = mock(Expression.class);
+    unionWithFunctionAndUnknownExpr = mock(Expression.class);
+    unionWithObjectAndUnknownExpr = mock(Expression.class);
+    unionWithFunctionAndObjectExpr = mock(Expression.class);
+    unionOfFunctionExpr = mock(Expression.class);
+    unionOfObjectExpr = mock(Expression.class);
+
+
+    when(unknownExpr.typeV2()).thenReturn(unknownType);
+    when(objectExpr.typeV2()).thenReturn(objectType);
+    when(functionExpr.typeV2()).thenReturn(functionType);
+    when(unionWithFunctionAndUnknownExpr.typeV2()).thenReturn(unionWithFunctionAndUnknown);
+    when(unionWithObjectAndUnknownExpr.typeV2()).thenReturn(unionWithObjectAndUnknown);
+    when(unionWithFunctionAndObjectExpr.typeV2()).thenReturn(unionWithFunctionAndObject);
+    when(unionOfFunctionExpr.typeV2()).thenReturn(unionOfFunctions);
+    when(unionOfObjectExpr.typeV2()).thenReturn(unionOfObjects);
   }
 
   @Test
   void testIsFor() {
-    SubscriptionContext ctx = Mockito.mock();
-    Mockito.when(ctx.typeTable()).thenReturn(Mockito.mock(TypeTable.class));
+    SubscriptionContext ctx = mock();
+    TypeTable typeTable = mock();
+    when(ctx.typeTable()).thenReturn(typeTable);
     assertThat(typeMatcher.evaluateFor(functionExpr, ctx)).isEqualTo(TriBool.TRUE);
     assertThat(typeMatcher.evaluateFor(unknownExpr, ctx)).isEqualTo(TriBool.UNKNOWN);
     assertThat(typeMatcher.evaluateFor(objectExpr, ctx)).isEqualTo(TriBool.FALSE);
@@ -121,8 +123,9 @@ void testIsFor() {
 
   @Test
   void testIsTrueFor() {
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(Mockito.mock(TypeTable.class));
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    TypeTable typeTable = mock();
+    when(ctx.typeTable()).thenReturn(typeTable);
     assertThat(typeMatcher.isTrueFor(functionExpr, ctx)).isTrue();
     assertThat(typeMatcher.isTrueFor(unknownExpr, ctx)).isFalse();
     assertThat(typeMatcher.isTrueFor(objectExpr, ctx)).isFalse();
@@ -149,8 +152,8 @@ def __init__(self):
       a
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     assertThat(TypeMatchers.isObjectOfType("my_file.A").evaluateFor(objectTypeExpression, ctx)).isEqualTo(TriBool.TRUE);
     assertThat(TypeMatchers.isObjectOfType("my_file.B").isTrueFor(objectTypeExpression, ctx)).isFalse();
@@ -169,8 +172,8 @@ def func1(): pass
       func1
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     assertThat(TypeMatchers.isObjectOfType("my_file.func1").evaluateFor(func1Expression, ctx)).isEqualTo(TriBool.FALSE);
     assertThat(func1Expression.typeV2()).isNotInstanceOf(UnknownType.class);
@@ -195,8 +198,8 @@ def __init__(self):
       a
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     assertThat(unknownTypeExpression.typeV2()).isInstanceOf(UnknownType.class);
     assertThat(knownTypeExpression.typeV2()).isInstanceOf(ObjectType.class);
@@ -219,8 +222,8 @@ def foo(param: int | A | str):
         param
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     assertThat(unionTypeExpression.typeV2()).isInstanceOf(UnionType.class);
     assertThat(InternalTypeMatchers.isAnyTypeInUnionSatisfying(TypeMatchers.isObjectOfType("my_file.A")).isTrueFor(unionTypeExpression, ctx)).isTrue();
diff --git a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherUtilsTest.java b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherUtilsTest.java
index f5ca3fbedf..648b2a2bc3 100644
--- a/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherUtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/plugins/python/api/types/v2/matchers/TypeMatcherUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,13 +20,14 @@
 import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
 import org.junit.platform.commons.annotation.Testable;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.SubscriptionContext;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.python.semantic.v2.TestProject;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 @Testable
 class TypeMatcherUtilsTest {
@@ -57,10 +58,10 @@ def bar(self):
     TypeMatcher allMatcher1 = List.of("bar", "foo").stream()
       .map(TypeMatchers::hasMember)
       .collect(TypeMatcherUtils.allCollector());
-    assertThat(allMatcher1.evaluateFor(expression, Mockito.mock())).isEqualTo(TriBool.TRUE);
+    assertThat(allMatcher1.evaluateFor(expression, mock())).isEqualTo(TriBool.TRUE);
 
     var allMatcher2 = TypeMatchers.all(Stream.of("bar", "foo").map(TypeMatchers::hasMember));
-    assertThat(allMatcher2.evaluateFor(expression, Mockito.mock())).isEqualTo(TriBool.TRUE);
+    assertThat(allMatcher2.evaluateFor(expression, mock())).isEqualTo(TriBool.TRUE);
   }
 
   @Test
@@ -83,8 +84,8 @@ class B :
       .map(TypeMatchers::isObjectOfType)
       .collect(TypeMatcherUtils.anyCollector());
 
-    var ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    var ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     assertThat(anyMatcher1.evaluateFor(expression, ctx)).isEqualTo(TriBool.TRUE);
 
diff --git a/python-frontend/src/test/java/org/sonar/python/DocstringExtractorTest.java b/python-frontend/src/test/java/org/sonar/python/DocstringExtractorTest.java
index 3e5723945a..67aaa88b29 100644
--- a/python-frontend/src/test/java/org/sonar/python/DocstringExtractorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/DocstringExtractorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/FileLinesVisitorTest.java b/python-frontend/src/test/java/org/sonar/python/FileLinesVisitorTest.java
index f0b1420e23..4987dea274 100644
--- a/python-frontend/src/test/java/org/sonar/python/FileLinesVisitorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/FileLinesVisitorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/IssueLocationTest.java b/python-frontend/src/test/java/org/sonar/python/IssueLocationTest.java
index fe18f2dbbc..32ba31021a 100644
--- a/python-frontend/src/test/java/org/sonar/python/IssueLocationTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/IssueLocationTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.Map;
 import org.junit.jupiter.api.Test;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
+import com.sonarsource.scanner.engine.sensor.test.fixtures.TestInputFileBuilder;
 import org.sonar.plugins.python.GeneratedIPythonFile;
 import org.sonar.plugins.python.PythonInputFile;
 import org.sonar.plugins.python.SonarQubePythonFile;
diff --git a/python-frontend/src/test/java/org/sonar/python/PythonCheckTest.java b/python-frontend/src/test/java/org/sonar/python/PythonCheckTest.java
index 9350e14f19..0f60a9338f 100644
--- a/python-frontend/src/test/java/org/sonar/python/PythonCheckTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/PythonCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,7 +19,6 @@
 import java.io.File;
 import java.util.List;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.IssueLocation;
 import org.sonar.plugins.python.api.PythonCheck;
 import org.sonar.plugins.python.api.PythonCheck.PreciseIssue;
@@ -74,7 +73,7 @@ public void visitFunctionDef(FunctionDef pyFunctionDefTree) {
     assertThat(primaryLocation.endLineOffset()).isEqualTo(9);
 
     assertThat(firstIssue.quickFixes()).isEmpty();
-    PythonTextEdit textEdit = Mockito.mock(PythonTextEdit.class);
+    PythonTextEdit textEdit = mock(PythonTextEdit.class);
     PythonQuickFix quickFix = PythonQuickFix.newQuickFix("New Quickfix")
       .addTextEdit(textEdit)
       .build();
@@ -100,6 +99,27 @@ public void visitFunctionDef(FunctionDef pyFunctionDefTree) {
     assertThat(firstIssue.cost()).isEqualTo(42);
   }
 
+  @Test
+  void test_flows() {
+    PythonVisitorCheck check = new PythonVisitorCheck() {
+      @Override
+      public void visitFunctionDef(FunctionDef pyFunctionDefTree) {
+        PreciseIssue issue = addIssue(pyFunctionDefTree.name(), MESSAGE);
+        issue.addFlow("Actual value first", List.of(IssueLocation.preciseLocation(pyFunctionDefTree.name(), "Actual value first.")));
+        issue.addFlow("Expected value first", List.of(IssueLocation.preciseLocation(pyFunctionDefTree.defKeyword(), "Expected value first.")));
+        super.visitFunctionDef(pyFunctionDefTree);
+      }
+    };
+
+    List issues = scanFileForIssues(check);
+    PreciseIssue firstIssue = issues.get(0);
+    assertThat(firstIssue.flows()).hasSize(2);
+    assertThat(firstIssue.flows().get(0).description()).isEqualTo("Actual value first");
+    assertThat(firstIssue.flows().get(0).locations()).hasSize(1);
+    assertThat(firstIssue.flows().get(0).locations().get(0).message()).isEqualTo("Actual value first.");
+    assertThat(firstIssue.flows().get(1).description()).isEqualTo("Expected value first");
+  }
+
   @Test
   void test_secondary_location() {
     PythonVisitorCheck check = new PythonVisitorCheck() {
diff --git a/python-frontend/src/test/java/org/sonar/python/PythonSubscriptionCheckTest.java b/python-frontend/src/test/java/org/sonar/python/PythonSubscriptionCheckTest.java
index 048ed38831..59838a9e41 100644
--- a/python-frontend/src/test/java/org/sonar/python/PythonSubscriptionCheckTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/PythonSubscriptionCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/PythonTestUtils.java b/python-frontend/src/test/java/org/sonar/python/PythonTestUtils.java
index 2aad1988ad..e93dfd71cd 100644
--- a/python-frontend/src/test/java/org/sonar/python/PythonTestUtils.java
+++ b/python-frontend/src/test/java/org/sonar/python/PythonTestUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -23,7 +23,6 @@
 import java.util.Map;
 import java.util.function.Predicate;
 import javax.annotation.CheckForNull;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.symbols.FunctionSymbol;
 import org.sonar.plugins.python.api.tree.Expression;
@@ -39,6 +38,8 @@
 import org.sonar.python.tree.TreeUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public final class PythonTestUtils {
 
@@ -106,10 +107,10 @@ public static  T getLastDescendant(Tree tree, Predicate pr
   }
 
   public static PythonFile pythonFile(String fileName) {
-    PythonFile pythonFile = Mockito.mock(PythonFile.class);
-    Mockito.when(pythonFile.fileName()).thenReturn(fileName);
+    PythonFile pythonFile = mock(PythonFile.class);
+    when(pythonFile.fileName()).thenReturn(fileName);
     try {
-      Mockito.when(pythonFile.uri()).thenReturn(Files.createTempFile(fileName, "py").toUri());
+      when(pythonFile.uri()).thenReturn(Files.createTempFile(fileName, "py").toUri());
     } catch (IOException e) {
       throw new IllegalStateException("Cannot create temporary file");
     }
diff --git a/python-frontend/src/test/java/org/sonar/python/PythonVisitorCheckTest.java b/python-frontend/src/test/java/org/sonar/python/PythonVisitorCheckTest.java
index 159fdb9744..89c367f7b0 100644
--- a/python-frontend/src/test/java/org/sonar/python/PythonVisitorCheckTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/PythonVisitorCheckTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/ReadWriteVisitorTest.java b/python-frontend/src/test/java/org/sonar/python/ReadWriteVisitorTest.java
index 4c54d0f39c..ec06db7d1b 100644
--- a/python-frontend/src/test/java/org/sonar/python/ReadWriteVisitorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/ReadWriteVisitorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/SubscriptionVisitorTest.java b/python-frontend/src/test/java/org/sonar/python/SubscriptionVisitorTest.java
index 7b5c68c31e..7052b21245 100644
--- a/python-frontend/src/test/java/org/sonar/python/SubscriptionVisitorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/SubscriptionVisitorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,10 +17,12 @@
 package org.sonar.python;
 
 import java.util.Collections;
+import java.util.List;
+import java.util.Set;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.regex.Pattern;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.project.configuration.AwsLambdaHandlerInfo;
 import org.sonar.plugins.python.api.project.configuration.ProjectConfiguration;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
@@ -31,7 +33,11 @@
 import org.sonar.plugins.python.api.PythonVisitorContext.Builder;
 import org.sonar.plugins.python.api.caching.CacheContext;
 import org.sonar.plugins.python.api.tree.ClassDef;
+import org.sonar.plugins.python.api.tree.ExpressionStatement;
 import org.sonar.plugins.python.api.tree.FileInput;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.NumericLiteral;
 import org.sonar.plugins.python.api.tree.StringElement;
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.python.regex.RegexContext;
@@ -41,6 +47,7 @@
 import org.sonarsource.analyzer.commons.regex.ast.FlagSet;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 class SubscriptionVisitorTest {
 
@@ -70,8 +77,8 @@ public void initialize(Context context) {
 
   @Test
   void exposed_visitor_data() {
-    FileInput fileInput = PythonTestUtils.parse("def foo(): ...");
-    var cache = Mockito.mock(CacheContext.class);
+    FileInput fileInput = PythonTestUtils.parse("import pytest\ndef foo(): ...");
+    var cache = mock(CacheContext.class);
 
     PythonFile pythonFile = PythonTestUtils.pythonFile("file");
     PythonVisitorContext context = new PythonVisitorContext.Builder(fileInput, pythonFile)
@@ -85,6 +92,7 @@ public void initialize(Context context) {
         context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> {
           assertThat(ctx.cacheContext()).isSameAs(cache);
           assertThat(ctx.pythonFile()).isEqualTo(pythonFile);
+          assertThat(ctx.isLikelyTestFile()).isTrue();
           assertThat(ctx.sourcePythonVersions()).isEqualTo(ProjectPythonVersion.currentVersions());
         });
       }
@@ -143,7 +151,7 @@ public void initialize(Context context) {
 
   @Test
   void callGraph() {
-    var callGraph = Mockito.mock(CallGraph.class);
+    var callGraph = mock(CallGraph.class);
     var latch = new CountDownLatch(1);
     var check = new PythonSubscriptionCheck() {
       @Override
@@ -165,4 +173,73 @@ public void initialize(Context context) {
       .withFailMessage("CallGraph was not accessed")
       .isZero();
   }
+
+  @Test
+  void reachingDefinitionAnalysis() {
+    var latch = new CountDownLatch(2);
+    var firstResult = new AtomicReference>();
+
+    var check1 = new PythonSubscriptionCheck() {
+      @Override
+      public void initialize(Context context) {
+        context.registerSyntaxNodeConsumer(Tree.Kind.EXPRESSION_STMT, ctx -> {
+          var exprStmt = (ExpressionStatement) ctx.syntaxNode();
+          var expr = exprStmt.expressions().get(0);
+          if (expr instanceof Name name && "x".equals(name.name())) {
+            var values = ctx.valuesAtLocation(name);
+            assertThat(values).extracting(e -> ((NumericLiteral) e).valueAsString()).containsExactly("42");
+            firstResult.set(values);
+            latch.countDown();
+          }
+        });
+      }
+    };
+
+    var check2 = new PythonSubscriptionCheck() {
+      @Override
+      public void initialize(Context context) {
+        context.registerSyntaxNodeConsumer(Tree.Kind.EXPRESSION_STMT, ctx -> {
+          var exprStmt = (ExpressionStatement) ctx.syntaxNode();
+          var expr = exprStmt.expressions().get(0);
+          if (expr instanceof Name name && "x".equals(name.name())) {
+            assertThat(ctx.valuesAtLocation(name)).isSameAs(firstResult.get());
+            latch.countDown();
+          }
+        });
+      }
+    };
+
+    var fileInput = PythonTestUtils.parse("def f():\n  x = 42\n  x");
+    var context = new Builder(fileInput, PythonTestUtils.pythonFile("file")).build();
+    SubscriptionVisitor.analyze(List.of(check1, check2), context);
+    assertThat(latch.getCount())
+      .withFailMessage("valuesAtLocation was not called by both checks")
+      .isZero();
+  }
+
+  @Test
+  void reachingDefinitionAnalysis_at_module_level() {
+    var latch = new CountDownLatch(1);
+
+    var check = new PythonSubscriptionCheck() {
+      @Override
+      public void initialize(Context context) {
+        context.registerSyntaxNodeConsumer(Tree.Kind.EXPRESSION_STMT, ctx -> {
+          var exprStmt = (ExpressionStatement) ctx.syntaxNode();
+          var expr = exprStmt.expressions().get(0);
+          if (expr instanceof Name name && "x".equals(name.name())) {
+            assertThat(ctx.valuesAtLocation(name)).extracting(e -> ((NumericLiteral) e).valueAsString()).containsExactly("42");
+            latch.countDown();
+          }
+        });
+      }
+    };
+
+    var fileInput = PythonTestUtils.parse("x = 42\nx");
+    var context = new Builder(fileInput, PythonTestUtils.pythonFile("file")).build();
+    SubscriptionVisitor.analyze(List.of(check), context);
+    assertThat(latch.getCount())
+      .withFailMessage("valuesAtLocation was not called at module level")
+      .isZero();
+  }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/TestPythonVisitorRunnerTest.java b/python-frontend/src/test/java/org/sonar/python/TestPythonVisitorRunnerTest.java
index 3a50647b73..6c0f115d6a 100644
--- a/python-frontend/src/test/java/org/sonar/python/TestPythonVisitorRunnerTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/TestPythonVisitorRunnerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/TokenLocationTest.java b/python-frontend/src/test/java/org/sonar/python/TokenLocationTest.java
index 835746421e..91a0c03203 100644
--- a/python-frontend/src/test/java/org/sonar/python/TokenLocationTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/TokenLocationTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/api/PythonKeywordTest.java b/python-frontend/src/test/java/org/sonar/python/api/PythonKeywordTest.java
index 7abb7e13a3..bcc29ae63c 100644
--- a/python-frontend/src/test/java/org/sonar/python/api/PythonKeywordTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/api/PythonKeywordTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/api/PythonPunctuatorTest.java b/python-frontend/src/test/java/org/sonar/python/api/PythonPunctuatorTest.java
index fddc43b4fe..265771713b 100644
--- a/python-frontend/src/test/java/org/sonar/python/api/PythonPunctuatorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/api/PythonPunctuatorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/api/PythonTokenTypeTest.java b/python-frontend/src/test/java/org/sonar/python/api/PythonTokenTypeTest.java
index 8889c9122d..812f98f83d 100644
--- a/python-frontend/src/test/java/org/sonar/python/api/PythonTokenTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/api/PythonTokenTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/caching/CacheContextImplTest.java b/python-frontend/src/test/java/org/sonar/python/caching/CacheContextImplTest.java
index 6426b2b0cd..2ca32a775e 100644
--- a/python-frontend/src/test/java/org/sonar/python/caching/CacheContextImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/caching/CacheContextImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/caching/CpdSerializerTest.java b/python-frontend/src/test/java/org/sonar/python/caching/CpdSerializerTest.java
index 4613a22e79..07b74761b6 100644
--- a/python-frontend/src/test/java/org/sonar/python/caching/CpdSerializerTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/caching/CpdSerializerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/caching/DummyCacheTest.java b/python-frontend/src/test/java/org/sonar/python/caching/DummyCacheTest.java
index a3721d4ab7..2d3aed64f6 100644
--- a/python-frontend/src/test/java/org/sonar/python/caching/DummyCacheTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/caching/DummyCacheTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/caching/PythonReadCacheImplTest.java b/python-frontend/src/test/java/org/sonar/python/caching/PythonReadCacheImplTest.java
index 85c0088942..d972430045 100644
--- a/python-frontend/src/test/java/org/sonar/python/caching/PythonReadCacheImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/caching/PythonReadCacheImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/caching/PythonWriteCacheImplTest.java b/python-frontend/src/test/java/org/sonar/python/caching/PythonWriteCacheImplTest.java
index 7aec187b38..ee14febd69 100644
--- a/python-frontend/src/test/java/org/sonar/python/caching/PythonWriteCacheImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/caching/PythonWriteCacheImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,31 +17,34 @@
 package org.sonar.python.caching;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.api.batch.sensor.cache.WriteCache;
 
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
 class PythonWriteCacheImplTest {
 
   @Test
   void write() {
     byte[] bytes = "hello".getBytes();
-    WriteCache writeCache = Mockito.spy(WriteCache.class);
+    WriteCache writeCache = spy(WriteCache.class);
 
     PythonWriteCacheImpl pythonWriteCache = new PythonWriteCacheImpl(writeCache);
     pythonWriteCache.write("key", bytes);
 
-    Mockito.verify(writeCache, Mockito.times(1))
+    verify(writeCache, times(1))
       .write("key", bytes);
   }
 
   @Test
   void copy_from_previous() {
-    WriteCache writeCache = Mockito.spy(WriteCache.class);
+    WriteCache writeCache = spy(WriteCache.class);
 
     PythonWriteCacheImpl pythonWriteCache = new PythonWriteCacheImpl(writeCache);
     pythonWriteCache.copyFromPrevious("key");
 
-    Mockito.verify(writeCache, Mockito.times(1))
+    verify(writeCache, times(1))
       .copyFromPrevious("key");
   }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/cfg/CfgUtilsTest.java b/python-frontend/src/test/java/org/sonar/python/cfg/CfgUtilsTest.java
index b0bcafa60e..d2f5855256 100644
--- a/python-frontend/src/test/java/org/sonar/python/cfg/CfgUtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/cfg/CfgUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,62 +16,112 @@
  */
 package org.sonar.python.cfg;
 
-
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
+import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.cfg.CfgBlock;
 import org.sonar.plugins.python.api.cfg.ControlFlowGraph;
 import org.sonar.plugins.python.api.tree.FileInput;
 import org.sonar.plugins.python.api.tree.FunctionDef;
-import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.python.PythonTestUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 class CfgUtilsTest {
 
-  private PythonFile file = Mockito.mock(PythonFile.class, "file1.py");
+  private final PythonFile file = mock(PythonFile.class, "file1.py");
 
   @Test
-  void unreachableBlocks_empty() {
+  void all_blocks_reachable_without_jumps() {
     ControlFlowGraph cfg = cfg(
       "x = 10"
     );
-    assertThat(CfgUtils.unreachableBlocks(cfg)).isEmpty();
+
+    assertAllBlocksReachable(cfg);
   }
 
   @Test
-  void unreachableBlocks_one() {
+  void return_makes_its_syntactic_successor_unreachable() {
     ControlFlowGraph cfg = cfg(
       "x = 10",
       "return",
       "y = 42"
     );
-    assertThat(CfgUtils.unreachableBlocks(cfg)).containsExactlyInAnyOrder(cfg.start().syntacticSuccessor());
+
+    assertOnlySyntacticSuccessorIsUnreachable(cfg);
   }
 
   @Test
-  void unreachableBlocks_conditional() {
+  void raise_makes_its_syntactic_successor_unreachable() {
     ControlFlowGraph cfg = cfg(
       "x = 10",
-      "return",
-      "if x > 9:",
-      "  print(x)",
+      "raise RuntimeError()",
       "y = 42"
     );
 
-    Set unreachableBlocks = new HashSet<>();
-    CfgBlock syntacticSuccessor = cfg.start().syntacticSuccessor();
-    unreachableBlocks.add(syntacticSuccessor);
-    unreachableBlocks.addAll(syntacticSuccessor.successors());
-    assertThat(CfgUtils.unreachableBlocks(cfg)).isEqualTo(unreachableBlocks);
+    assertOnlySyntacticSuccessorIsUnreachable(cfg);
   }
 
+  @Test
+  void break_makes_its_syntactic_successor_unreachable() {
+    ControlFlowGraph cfg = cfg(
+      "while condition:",
+      "  break",
+      "  unreachable()",
+      "after_loop()"
+    );
+
+    assertOnlySyntacticSuccessorIsUnreachable(cfg);
+  }
 
+  @Test
+  void continue_makes_its_syntactic_successor_unreachable() {
+    ControlFlowGraph cfg = cfg(
+      "while condition:",
+      "  continue",
+      "  unreachable()",
+      "after_loop()"
+    );
+
+    assertOnlySyntacticSuccessorIsUnreachable(cfg);
+  }
+
+  @Test
+  void multiple_blocks_reachable_with_branching() {
+    ControlFlowGraph cfg = cfg(
+      "if condition:",
+      "  if_branch()",
+      "else:",
+      "  else_branch()",
+      "after_branch()"
+    );
+
+    assertThat(cfg.start().successors()).hasSize(2);
+    assertAllBlocksReachable(cfg);
+  }
+
+  private static void assertAllBlocksReachable(ControlFlowGraph cfg) {
+    assertThat(CfgUtils.reachableBlocks(cfg)).isEqualTo(cfg.blocks());
+    assertThat(CfgUtils.unreachableBlocks(cfg)).isEmpty();
+  }
+
+  private static void assertOnlySyntacticSuccessorIsUnreachable(ControlFlowGraph cfg) {
+    Set syntacticSuccessors = cfg.blocks().stream()
+      .map(CfgBlock::syntacticSuccessor)
+      .filter(Objects::nonNull)
+      .collect(Collectors.toSet());
+    assertThat(syntacticSuccessors).hasSize(1);
+
+    Set expectedReachableBlocks = new HashSet<>(cfg.blocks());
+    expectedReachableBlocks.removeAll(syntacticSuccessors);
+    assertThat(CfgUtils.reachableBlocks(cfg)).isEqualTo(expectedReachableBlocks);
+    assertThat(CfgUtils.unreachableBlocks(cfg)).isEqualTo(syntacticSuccessors);
+  }
 
   private ControlFlowGraph cfg(String... lines) {
     FileInput fileInput = PythonTestUtils.parse("def wrapper():", Arrays.stream(lines).map(s -> "  " + s).collect(Collectors.joining("\n")));
diff --git a/python-frontend/src/test/java/org/sonar/python/cfg/PythonCfgBlockTest.java b/python-frontend/src/test/java/org/sonar/python/cfg/PythonCfgBlockTest.java
index 46e2206b76..b980debda7 100644
--- a/python-frontend/src/test/java/org/sonar/python/cfg/PythonCfgBlockTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/cfg/PythonCfgBlockTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/DefinedVariablesAnalysisTest.java b/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/DefinedVariablesAnalysisTest.java
index 72ca96e793..e00bd995f0 100644
--- a/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/DefinedVariablesAnalysisTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/DefinedVariablesAnalysisTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,7 +19,6 @@
 import java.util.Arrays;
 import java.util.stream.Collectors;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.cfg.CfgValidator;
 import org.sonar.plugins.python.api.cfg.ControlFlowGraph;
 import org.sonar.plugins.python.api.tree.FileInput;
@@ -27,6 +26,8 @@
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.python.PythonTestUtils;
 
+import static org.mockito.Mockito.mock;
+
 /**
  * This Defined Variable Analysis Test uses a meta-language to specify the expected values for each basic block.
  * 
                  
@@ -48,7 +49,7 @@
  * 3. the name of the function is the identifier of the basic block
  */
 class DefinedVariablesAnalysisTest {
-  private PythonFile file = Mockito.mock(PythonFile.class, "file1.py");
+  private PythonFile file = mock(PythonFile.class, "file1.py");
 
   @Test
   void test_simple_def() {
diff --git a/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/LiveVariablesAnalysisTest.java b/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/LiveVariablesAnalysisTest.java
index a0b0baddc6..8fd83c2872 100644
--- a/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/LiveVariablesAnalysisTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/LiveVariablesAnalysisTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,7 +21,6 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.cfg.CfgValidator;
 import org.sonar.plugins.python.api.cfg.ControlFlowGraph;
@@ -31,6 +30,7 @@
 import org.sonar.python.PythonTestUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 /**
  * This Live Variable Analysis Test uses a meta-language to specify the expected LVA values for each basic block.
@@ -53,7 +53,7 @@
  * 3. the name of the function is the identifier of the basic block
  */
 class LiveVariablesAnalysisTest {
-  private PythonFile file = Mockito.mock(PythonFile.class, "file1.py");
+  private PythonFile file = mock(PythonFile.class, "file1.py");
 
   @Test
   void test_simple_kill() {
diff --git a/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/ReachingDefinitionsAnalysisTest.java b/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/ReachingDefinitionsAnalysisTest.java
index 5cd832656f..1d4626a6aa 100644
--- a/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/ReachingDefinitionsAnalysisTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/cfg/fixpoint/ReachingDefinitionsAnalysisTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -23,9 +23,9 @@
 import static org.sonar.python.PythonTestUtils.lastExpression;
 import static org.sonar.python.PythonTestUtils.lastExpressionInFunction;
 import static org.sonar.python.PythonTestUtils.parse;
+import static org.mockito.Mockito.mock;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.tree.ExpressionStatement;
@@ -34,7 +34,7 @@
 import org.sonar.plugins.python.api.tree.NumericLiteral;
 
 class ReachingDefinitionsAnalysisTest {
-  private final PythonFile file = Mockito.mock(PythonFile.class, "file1.py");
+  private final PythonFile file = mock(PythonFile.class, "file1.py");
   ReachingDefinitionsAnalysis analysis = new ReachingDefinitionsAnalysis(file);
 
   @Test
@@ -82,12 +82,37 @@ void valuesAtLocation_branches() {
   @Test
   void valuesAtLocation_outside_function() {
     Name x = (Name) lastExpression("x = 42; x");
-    assertThat(analysis.valuesAtLocation(x)).isEmpty();
+    assertThat(analysis.valuesAtLocation(x)).extracting(ReachingDefinitionsAnalysisTest::getValueAsString).containsExactly("42");
   }
 
   @Test
   void valuesAtLocation_outside_function_annotated() {
     Name x = (Name) lastExpression("x: int = 42; x");
+    assertThat(analysis.valuesAtLocation(x)).extracting(ReachingDefinitionsAnalysisTest::getValueAsString).containsExactly("42");
+  }
+
+  @Test
+  void valuesAtLocation_outside_function_branches() {
+    Name x = (Name) lastExpression(
+      "if p:",
+      "  x = 1",
+      "else:",
+      "  x = 2",
+      "x"
+    );
+    assertThat(analysis.valuesAtLocation(x)).extracting(ReachingDefinitionsAnalysisTest::getValueAsString).containsExactlyInAnyOrder("1", "2");
+  }
+
+  @Test
+  void valuesAtLocation_outside_function_try_stmt() {
+    Name x = (Name) lastExpression(
+      "x = 1",
+      "try:",
+      "  x = 2",
+      "except:",
+      "  pass",
+      "x"
+    );
     assertThat(analysis.valuesAtLocation(x)).isEmpty();
   }
 
@@ -97,6 +122,12 @@ void valuesAtLocation_invalid_cfg() {
     assertThat(analysis.valuesAtLocation(x)).isEmpty();
   }
 
+  @Test
+  void valuesAtLocation_outside_function_invalid_cfg() {
+    Name x = (Name) lastExpression("x = 42", "break", "x");
+    assertThat(analysis.valuesAtLocation(x)).isEmpty();
+  }
+
   @Test
   void valuesAtLocation_no_name_assignment() {
     Name x = (Name) lastExpressionInFunction("x.foo = 42", "x");
@@ -158,6 +189,34 @@ void compound_assignments() {
     assertThat(analysis.valuesAtLocation(x)).isEmpty();
   }
 
+  @Test
+  void try_stmt_in_nested_function() {
+    Name x = (Name) lastExpressionInFunction(
+      "x = 1",
+      "def inner():",
+      "  try:",
+      "    pass",
+      "  except:",
+      "    pass",
+      "x"
+    );
+    assertThat(analysis.valuesAtLocation(x)).extracting(ReachingDefinitionsAnalysisTest::getValueAsString).containsExactly("1");
+  }
+
+  @Test
+  void valuesAtLocation_outside_function_try_stmt_in_nested_function() {
+    Name x = (Name) lastExpression(
+      "x = 1",
+      "def f():",
+      "  try:",
+      "    pass",
+      "  except:",
+      "    pass",
+      "x"
+    );
+    assertThat(analysis.valuesAtLocation(x)).extracting(ReachingDefinitionsAnalysisTest::getValueAsString).containsExactly("1");
+  }
+
   @Test
   void try_stmt() {
     Name x = (Name) lastExpressionInFunction(
diff --git a/python-frontend/src/test/java/org/sonar/python/index/AliasDescriptorTest.java b/python-frontend/src/test/java/org/sonar/python/index/AliasDescriptorTest.java
index 11f43cf005..19463efb03 100644
--- a/python-frontend/src/test/java/org/sonar/python/index/AliasDescriptorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/index/AliasDescriptorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/index/AmbiguousDescriptorTest.java b/python-frontend/src/test/java/org/sonar/python/index/AmbiguousDescriptorTest.java
index 71b5b6e2b3..c5c2b9bd18 100644
--- a/python-frontend/src/test/java/org/sonar/python/index/AmbiguousDescriptorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/index/AmbiguousDescriptorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/index/ClassDescriptorTest.java b/python-frontend/src/test/java/org/sonar/python/index/ClassDescriptorTest.java
index 5d902c543d..d632ed6feb 100644
--- a/python-frontend/src/test/java/org/sonar/python/index/ClassDescriptorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/index/ClassDescriptorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/index/DescriptorToProtobufTestUtils.java b/python-frontend/src/test/java/org/sonar/python/index/DescriptorToProtobufTestUtils.java
index 2fa98a1786..aa489fab42 100644
--- a/python-frontend/src/test/java/org/sonar/python/index/DescriptorToProtobufTestUtils.java
+++ b/python-frontend/src/test/java/org/sonar/python/index/DescriptorToProtobufTestUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/index/DescriptorUtilsTest.java b/python-frontend/src/test/java/org/sonar/python/index/DescriptorUtilsTest.java
index 3f75000459..28edec322d 100644
--- a/python-frontend/src/test/java/org/sonar/python/index/DescriptorUtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/index/DescriptorUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/index/FunctionDescriptorTest.java b/python-frontend/src/test/java/org/sonar/python/index/FunctionDescriptorTest.java
index 16d03da7e7..bf13e61438 100644
--- a/python-frontend/src/test/java/org/sonar/python/index/FunctionDescriptorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/index/FunctionDescriptorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/index/RoundTripDescriptorTest.java b/python-frontend/src/test/java/org/sonar/python/index/RoundTripDescriptorTest.java
index e58cef1631..bcf60dfcc0 100644
--- a/python-frontend/src/test/java/org/sonar/python/index/RoundTripDescriptorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/index/RoundTripDescriptorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/index/VariableDescriptorTest.java b/python-frontend/src/test/java/org/sonar/python/index/VariableDescriptorTest.java
index 901b27287a..93ee4b4810 100644
--- a/python-frontend/src/test/java/org/sonar/python/index/VariableDescriptorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/index/VariableDescriptorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/lexer/IPythonLexerTest.java b/python-frontend/src/test/java/org/sonar/python/lexer/IPythonLexerTest.java
index 51de4a1d2c..09b3f29b08 100644
--- a/python-frontend/src/test/java/org/sonar/python/lexer/IPythonLexerTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/lexer/IPythonLexerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/lexer/PythonLexerTest.java b/python-frontend/src/test/java/org/sonar/python/lexer/PythonLexerTest.java
index a6f8e0185c..404d2987c0 100644
--- a/python-frontend/src/test/java/org/sonar/python/lexer/PythonLexerTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/lexer/PythonLexerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/metrics/CognitiveComplexityVisitorTest.java b/python-frontend/src/test/java/org/sonar/python/metrics/CognitiveComplexityVisitorTest.java
index 17e643c51f..c3d05a4884 100644
--- a/python-frontend/src/test/java/org/sonar/python/metrics/CognitiveComplexityVisitorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/metrics/CognitiveComplexityVisitorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/metrics/ComplexityVisitorTest.java b/python-frontend/src/test/java/org/sonar/python/metrics/ComplexityVisitorTest.java
index c65e370560..ac15e316b1 100644
--- a/python-frontend/src/test/java/org/sonar/python/metrics/ComplexityVisitorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/metrics/ComplexityVisitorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/metrics/FileMetricsTest.java b/python-frontend/src/test/java/org/sonar/python/metrics/FileMetricsTest.java
index 415831e856..36e0ff2714 100644
--- a/python-frontend/src/test/java/org/sonar/python/metrics/FileMetricsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/metrics/FileMetricsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/PythonParserAssert.java b/python-frontend/src/test/java/org/sonar/python/parser/PythonParserAssert.java
index 926935e194..741c5c0452 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/PythonParserAssert.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/PythonParserAssert.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/PythonParserTest.java b/python-frontend/src/test/java/org/sonar/python/parser/PythonParserTest.java
index 1c65ee597a..168c18ede5 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/PythonParserTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/PythonParserTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/RuleTest.java b/python-frontend/src/test/java/org/sonar/python/parser/RuleTest.java
index b184bef14d..a11d0dbb64 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/RuleTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/RuleTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/CasePatternsTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/CasePatternsTest.java
index 482c6f88cd..b8a2091f26 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/CasePatternsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/CasePatternsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ClassDefTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ClassDefTest.java
index d04f3ed7bf..3f32b806f6 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ClassDefTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ClassDefTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/DecoratorTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/DecoratorTest.java
index 892ca431e3..2a6f03605f 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/DecoratorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/DecoratorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ExceptClauseTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ExceptClauseTest.java
index 394a036ef2..40a58fc0af 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ExceptClauseTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ExceptClauseTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ForStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ForStatementTest.java
index 7a3ed0dcc5..1ff3b3a860 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ForStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/ForStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/FuncDefTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/FuncDefTest.java
index 5e80dec613..78981d4f00 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/FuncDefTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/FuncDefTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/IfStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/IfStatementTest.java
index 05912da639..90c97b7029 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/IfStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/IfStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/MatchStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/MatchStatementTest.java
index af6b5ebcf6..320d73af9a 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/MatchStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/MatchStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/SuiteTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/SuiteTest.java
index 5bf587e731..861a7a7f7a 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/SuiteTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/SuiteTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/TryStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/TryStatementTest.java
index 5402007afc..9ab194d7ea 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/TryStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/TryStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/WhileStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/WhileStatementTest.java
index 79e89ff761..7202ac5d4a 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/WhileStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/WhileStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/WithStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/WithStatementTest.java
index f84b4c6c27..f7eeeacfa5 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/WithStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/compound/statements/WithStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/expressions/ArgumentListTest.java b/python-frontend/src/test/java/org/sonar/python/parser/expressions/ArgumentListTest.java
index 0ab113218b..e8f8f1966c 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/expressions/ArgumentListTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/expressions/ArgumentListTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/expressions/ExpressionTest.java b/python-frontend/src/test/java/org/sonar/python/parser/expressions/ExpressionTest.java
index 88d4a54c3b..e47bb457fd 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/expressions/ExpressionTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/expressions/ExpressionTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/python/v3/PythonV3Test.java b/python-frontend/src/test/java/org/sonar/python/parser/python/v3/PythonV3Test.java
index a68813966a..687e1bf7d5 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/python/v3/PythonV3Test.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/python/v3/PythonV3Test.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/AssertStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/AssertStatementTest.java
index 496c84022f..0af1032e58 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/AssertStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/AssertStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/BreakStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/BreakStatementTest.java
index 65cd7585a0..961181e432 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/BreakStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/BreakStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ContinueStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ContinueStatementTest.java
index 6afa274fb6..41990c4800 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ContinueStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ContinueStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/DelStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/DelStatementTest.java
index 5b75de52b9..dd47f22ecb 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/DelStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/DelStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ExecStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ExecStatementTest.java
index b7bf310053..83792dfcda 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ExecStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ExecStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ExpressionStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ExpressionStatementTest.java
index a92a09dce4..b622ef3afb 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ExpressionStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ExpressionStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/GlobalStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/GlobalStatementTest.java
index 70d3e7e6f2..43261b4a9d 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/GlobalStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/GlobalStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ImportStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ImportStatementTest.java
index cdcf57316f..83b4005c05 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ImportStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ImportStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/NonlocalStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/NonlocalStatementTest.java
index 5381821d37..53f4ddefc9 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/NonlocalStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/NonlocalStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/PassStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/PassStatementTest.java
index 9e489fab6a..801b4bd919 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/PassStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/PassStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/PrintStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/PrintStatementTest.java
index 765ec62d36..b17c3cf322 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/PrintStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/PrintStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/RaiseStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/RaiseStatementTest.java
index 62a2eabba0..fd11ec39df 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/RaiseStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/RaiseStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ReturnStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ReturnStatementTest.java
index d36add04bc..2e42ead0b2 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ReturnStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/ReturnStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/SimpleStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/SimpleStatementTest.java
index 9f60d1a179..dc797fec98 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/SimpleStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/SimpleStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/YieldStatementTest.java b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/YieldStatementTest.java
index 801c4c30b9..2acef2fe45 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/YieldStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/simple/statements/YieldStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/parser/toplevel/FileInputTest.java b/python-frontend/src/test/java/org/sonar/python/parser/toplevel/FileInputTest.java
index 2e4ccfdba3..3e85bf2277 100644
--- a/python-frontend/src/test/java/org/sonar/python/parser/toplevel/FileInputTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/parser/toplevel/FileInputTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/project/config/ProjectConfigurationBuilderTest.java b/python-frontend/src/test/java/org/sonar/python/project/config/ProjectConfigurationBuilderTest.java
new file mode 100644
index 0000000000..d611450649
--- /dev/null
+++ b/python-frontend/src/test/java/org/sonar/python/project/config/ProjectConfigurationBuilderTest.java
@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.project.config;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ProjectConfigurationBuilderTest {
+
+  @Test
+  void clear_removesCollectedAwsLambdaHandlers() {
+    var builder = new ProjectConfigurationBuilder()
+      .addAwsLambdaHandler("acme", "acme.handler");
+
+    assertThat(builder.build().awsProjectConfiguration().awsLambdaHandlers()).hasSize(1);
+
+    builder.clear();
+
+    assertThat(builder.build().awsProjectConfiguration().awsLambdaHandlers()).isEmpty();
+  }
+}
diff --git a/python-frontend/src/test/java/org/sonar/python/project/config/SignatureBasedAwsLambdaHandlersCollectorTest.java b/python-frontend/src/test/java/org/sonar/python/project/config/SignatureBasedAwsLambdaHandlersCollectorTest.java
index 2761f5d5b8..b0e6a6ac64 100644
--- a/python-frontend/src/test/java/org/sonar/python/project/config/SignatureBasedAwsLambdaHandlersCollectorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/project/config/SignatureBasedAwsLambdaHandlersCollectorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/quickfix/TextEditUtilsTest.java b/python-frontend/src/test/java/org/sonar/python/quickfix/TextEditUtilsTest.java
index 77d497e60c..af93438b7f 100644
--- a/python-frontend/src/test/java/org/sonar/python/quickfix/TextEditUtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/quickfix/TextEditUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,7 +18,6 @@
 
 import java.util.List;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.PythonLine;
 import org.sonar.plugins.python.api.quickfix.PythonTextEdit;
 import org.sonar.plugins.python.api.tree.CallExpression;
@@ -33,6 +32,7 @@
 import org.sonarsource.analyzer.commons.collections.ListUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 import static org.sonar.python.PythonTestUtils.parse;
 
@@ -232,7 +232,7 @@ private void assertTextEditLocation(PythonTextEdit textEdit, int startLine, int
   }
 
   private static Token mockToken(String value, int line, int column) {
-    Token token = Mockito.mock(Token.class);
+    Token token = mock(Token.class);
     when(token.firstToken()).thenReturn(token);
     when(token.lastToken()).thenReturn(token);
 
diff --git a/python-frontend/src/test/java/org/sonar/python/regex/PythonAnalyzerRegexSourceTest.java b/python-frontend/src/test/java/org/sonar/python/regex/PythonAnalyzerRegexSourceTest.java
index 6576200093..1c18eb05c8 100644
--- a/python-frontend/src/test/java/org/sonar/python/regex/PythonAnalyzerRegexSourceTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/regex/PythonAnalyzerRegexSourceTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/regex/PythonRegexIssueLocationTest.java b/python-frontend/src/test/java/org/sonar/python/regex/PythonRegexIssueLocationTest.java
index 813785b713..9891efa3d5 100644
--- a/python-frontend/src/test/java/org/sonar/python/regex/PythonRegexIssueLocationTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/regex/PythonRegexIssueLocationTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/regex/PythonStringCharacterParserTest.java b/python-frontend/src/test/java/org/sonar/python/regex/PythonStringCharacterParserTest.java
index 869654380b..828348f088 100644
--- a/python-frontend/src/test/java/org/sonar/python/regex/PythonStringCharacterParserTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/regex/PythonStringCharacterParserTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/regex/RegexParserTestUtils.java b/python-frontend/src/test/java/org/sonar/python/regex/RegexParserTestUtils.java
index 63bce4e21f..6ff313508d 100644
--- a/python-frontend/src/test/java/org/sonar/python/regex/RegexParserTestUtils.java
+++ b/python-frontend/src/test/java/org/sonar/python/regex/RegexParserTestUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/AmbiguousSymbolTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/AmbiguousSymbolTest.java
index e95bc3198b..675ac6536b 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/AmbiguousSymbolTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/AmbiguousSymbolTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/ClassLocalSymbolsTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/ClassLocalSymbolsTest.java
index 8296731703..c7ffcfef14 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/ClassLocalSymbolsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/ClassLocalSymbolsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolImplTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolImplTest.java
index 3c92a870f2..f0c034b83f 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolTest.java
index 9a98e6753b..ce2427547e 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/ClassSymbolTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/DependencyGraphTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/DependencyGraphTest.java
index 1930d11ccf..a44b1a9872 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/DependencyGraphTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/DependencyGraphTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/FullyQualifiedNameTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/FullyQualifiedNameTest.java
index 31065e16e8..d996033f3c 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/FullyQualifiedNameTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/FullyQualifiedNameTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,7 +19,6 @@
 import java.net.URI;
 import javax.annotation.Nullable;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.PythonVisitorContext;
 import org.sonar.plugins.python.api.symbols.Symbol;
@@ -37,6 +36,7 @@
 import org.sonar.python.tree.PythonTreeMaker;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 import static org.sonar.python.PythonTestUtils.getAllDescendant;
 import static org.sonar.python.PythonTestUtils.getFirstChild;
@@ -467,7 +467,7 @@ void from_import_submodule() {
   void init_module_relative_import() {
     String code = String.join(System.getProperty("line.separator"), "from .. import fn", "fn()", "class A: pass");
     FileInput fileInput = new PythonTreeMaker().fileInput(PythonParser.create().parse(code));
-    PythonFile pythonFile = Mockito.mock(PythonFile.class, "__init__.py");
+    PythonFile pythonFile = mock(PythonFile.class, "__init__.py");
     when(pythonFile.fileName()).thenReturn("__init__.py");
     when(pythonFile.uri()).thenReturn(URI.create("mod/__init__.py"));
     PythonVisitorContext context = new PythonVisitorContext.Builder(fileInput, pythonFile).packageName("foo.bar").build();
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/FunctionSymbolTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/FunctionSymbolTest.java
index 9c7ec36329..ee9ed74c65 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/FunctionSymbolTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/FunctionSymbolTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/MatchStatementSymbolsTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/MatchStatementSymbolsTest.java
index 67beb595c8..b5f195261c 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/MatchStatementSymbolsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/MatchStatementSymbolsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/ProjectLevelSymbolTableTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/ProjectLevelSymbolTableTest.java
index 35611c299e..cee912ef5d 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/ProjectLevelSymbolTableTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/ProjectLevelSymbolTableTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -1242,6 +1242,31 @@ void projectPackages() {
     assertThat(projectLevelSymbolTable.projectBasePackages()).containsExactlyInAnyOrder("first", "second", "third");
   }
 
+  @Test
+  void clear_removesProjectDerivedState() {
+    var projectLevelSymbolTable = empty();
+    var descriptor = new FunctionDescriptor.FunctionDescriptorBuilder()
+      .withName("function")
+      .withFullyQualifiedName("acme.module.function")
+      .build();
+    projectLevelSymbolTable.insertEntry("acme.module", Set.of(descriptor));
+    projectLevelSymbolTable.addProjectPackage("acme.package");
+    var typeShedProvider = projectLevelSymbolTable.typeShedDescriptorsProvider();
+    var stubSymbols = projectLevelSymbolTable.stubFilesSymbols();
+
+    assertThat(projectLevelSymbolTable.getSymbol("acme.module.function")).isNotNull();
+    assertThat(projectLevelSymbolTable.projectBasePackages()).containsExactly("acme");
+
+    projectLevelSymbolTable.clear();
+
+    assertThat(projectLevelSymbolTable.getSymbolsFromModule("acme.module")).isNull();
+    assertThat(projectLevelSymbolTable.getSymbol("acme.module.function")).isNull();
+    assertThat(projectLevelSymbolTable.importsByModule()).isEmpty();
+    assertThat(projectLevelSymbolTable.projectBasePackages()).isEmpty();
+    assertThat(projectLevelSymbolTable.typeShedDescriptorsProvider()).isNotSameAs(typeShedProvider);
+    assertThat(projectLevelSymbolTable.stubFilesSymbols()).isNotSameAs(stubSymbols);
+  }
+
   @Test
   void hasModuleWithPrefix_detectsNamespacePackages() {
     var symbolTable = empty();
@@ -1263,4 +1288,91 @@ void hasModuleWithPrefix_detectsNamespacePackages() {
     assertThat(symbolTable.hasModuleWithPrefix("acme.ma")).isFalse();
   }
 
+  @Test
+  void django_views_with_url_patterns() {
+    String[] urls = {
+      "from django.urls import path",
+      "import views",
+      "urlpatterns = [",
+      "  path('article//', views.article_detail, name='article_detail'),",
+      "  path('user//post//', views.user_post, name='user_post'),",
+      "]"
+    };
+
+    ProjectLevelSymbolTable projectSymbolTable = empty();
+    projectSymbolTable.addModule(parseWithoutSymbols(urls), "", pythonFile("urls.py"));
+
+    assertThat(projectSymbolTable.isDjangoView("views.article_detail")).isTrue();
+    assertThat(projectSymbolTable.getDjangoViewInfo("views.article_detail"))
+      .isPresent()
+      .hasValueSatisfying(info -> assertThat(info.urlPatterns()).containsExactly("article//"));
+
+    assertThat(projectSymbolTable.isDjangoView("views.user_post")).isTrue();
+    assertThat(projectSymbolTable.getDjangoViewInfo("views.user_post"))
+      .isPresent()
+      .hasValueSatisfying(info -> assertThat(info.urlPatterns()).containsExactly("user//post//"));
+  }
+
+  @Test
+  void django_views_with_empty_url_patterns() {
+    String[] urls = {
+      "from django.urls import path",
+      "import views",
+      "urlpatterns = [path('', views.no_pattern_view)]"
+    };
+
+    ProjectLevelSymbolTable projectSymbolTable = empty();
+    projectSymbolTable.addModule(parseWithoutSymbols(urls), "", pythonFile("urls.py"));
+
+    assertThat(projectSymbolTable.isDjangoView("views.no_pattern_view")).isTrue();
+    assertThat(projectSymbolTable.getDjangoViewInfo("views.no_pattern_view"))
+      .isPresent()
+      .hasValueSatisfying(info -> assertThat(info.urlPatterns()).containsExactly(""));
+  }
+
+  @Test
+  void django_views_with_non_string_route() {
+    // Test case where route argument is not a STRING_LITERAL
+    String[] urls = {
+      "from django.urls import path",
+      "import views",
+      "route_var = 'dynamic-route'",
+      "urlpatterns = [path(route_var, views.dynamic_view)]"
+    };
+
+    ProjectLevelSymbolTable projectSymbolTable = empty();
+    projectSymbolTable.addModule(parseWithoutSymbols(urls), "", pythonFile("urls.py"));
+
+    assertThat(projectSymbolTable.isDjangoView("views.dynamic_view")).isTrue();
+    assertThat(projectSymbolTable.getDjangoViewInfo("views.dynamic_view"))
+      .isPresent()
+      .hasValueSatisfying(info -> assertThat(info.urlPatterns()).isEmpty());
+  }
+
+  @Test
+  void django_views_with_re_path() {
+    // Test re_path() with named groups
+    String[] urls = {
+      "from django.urls import re_path",
+      "import views",
+      "urlpatterns = [",
+      "  re_path(r'^items/(?P\\d+)/$', views.item_detail),",
+      "  re_path(r'^items/(?P\\d+)/(?P[\\w-]+)/$', views.item_with_slug),",
+      "]"
+    };
+
+    ProjectLevelSymbolTable projectSymbolTable = empty();
+    projectSymbolTable.addModule(parseWithoutSymbols(urls), "", pythonFile("urls.py"));
+
+    assertThat(projectSymbolTable.isDjangoView("views.item_detail")).isTrue();
+    assertThat(projectSymbolTable.getDjangoViewInfo("views.item_detail"))
+      .isPresent()
+      .hasValueSatisfying(info -> assertThat(info.urlPatterns()).containsExactly("^items/(?P\\d+)/$"));
+
+    assertThat(projectSymbolTable.isDjangoView("views.item_with_slug")).isTrue();
+    assertThat(projectSymbolTable.getDjangoViewInfo("views.item_with_slug"))
+      .isPresent()
+      .hasValueSatisfying(info -> assertThat(info.urlPatterns()).containsExactly("^items/(?P\\d+)/(?P[\\w-]+)/$"));
+  }
+
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/SelfSymbolImplTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/SelfSymbolImplTest.java
index 8076b065b1..a37da1e583 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/SelfSymbolImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/SelfSymbolImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/SymbolImplTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/SymbolImplTest.java
index 24aed1544c..e04e7be701 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/SymbolImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/SymbolImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/SymbolTableBuilderTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/SymbolTableBuilderTest.java
index 854797cd0a..946385193f 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/SymbolTableBuilderTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/SymbolTableBuilderTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -35,6 +35,7 @@
 import org.sonar.plugins.python.api.symbols.Usage;
 import org.sonar.plugins.python.api.tree.BaseTreeVisitor;
 import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.ClassDef;
 import org.sonar.plugins.python.api.tree.ComprehensionExpression;
 import org.sonar.plugins.python.api.tree.DictCompExpression;
 import org.sonar.plugins.python.api.tree.ExpressionStatement;
@@ -44,6 +45,7 @@
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.tree.Tuple;
+import org.sonar.plugins.python.api.tree.TypeAliasStatement;
 import org.sonar.python.PythonTestUtils;
 import org.sonar.python.TestPythonVisitorRunner;
 import org.sonar.python.tree.TreeUtils;
@@ -636,6 +638,33 @@ void type_alias_declaration() {
     assertThat(symbolByName.get("M").usages().get(0).kind()).isEqualTo(Usage.Kind.TYPE_ALIAS_DECLARATION);
   }
 
+  @Test
+  void class_type_param_bound_resolved_in_enclosing_scope() {
+    FileInput tree = PythonTestUtils.parse(
+      "class BaseBound:",
+      "    pass",
+      "class Foo[T: BaseBound]:",
+      "    pass"
+    );
+    ClassDef fooClass = (ClassDef) PythonTestUtils.getLastDescendant(tree, t -> t.is(Tree.Kind.CLASSDEF));
+    Name boundName = (Name) fooClass.typeParams().typeParamsList().get(0).typeAnnotation().expression();
+    assertThat(boundName.name()).isEqualTo("BaseBound");
+    assertThat(boundName.symbol()).isNotNull();
+    assertThat(boundName.symbol().name()).isEqualTo("BaseBound");
+  }
+
+  @Test
+  void type_alias_type_params_registered() {
+    FileInput tree = PythonTestUtils.parse("type Alias[T] = list[T]");
+    TypeAliasStatement typeAlias = (TypeAliasStatement) tree.statements().statements().get(0);
+    Name typeParamName = typeAlias.typeParams().typeParamsList().get(0).name();
+    assertThat(typeParamName.name()).isEqualTo("T");
+    assertThat(typeParamName.symbol()).isNotNull();
+    assertThat(typeParamName.symbol().usages())
+      .extracting(Usage::kind)
+      .contains(Usage.Kind.TYPE_PARAM_DECLARATION);
+  }
+
   private static class TestVisitor extends BaseTreeVisitor {
     @Override
     public void visitFunctionDef(FunctionDef pyFunctionDefTree) {
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/SymbolUtilsTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/SymbolUtilsTest.java
index ce7cbeb13f..f6972ab73f 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/SymbolUtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/SymbolUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -38,12 +38,14 @@
 import java.net.URISyntaxException;
 import java.nio.file.Files;
 import java.nio.file.InvalidPathException;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.List;
 import java.util.Objects;
 import javax.annotation.Nullable;
+import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
+import org.junit.jupiter.api.io.TempDir;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.symbols.ClassSymbol;
 import org.sonar.plugins.python.api.symbols.FunctionSymbol;
@@ -65,14 +67,6 @@
 
 class SymbolUtilsTest {
 
-  @Test
-  void package_name_by_file() {
-    String baseDir = new File("src/test/resources").getAbsoluteFile().getAbsolutePath();
-    assertThat(pythonPackageName(new File(baseDir, "packages/sound/__init__.py"), baseDir)).isEqualTo("sound");
-    assertThat(pythonPackageName(new File(baseDir, "packages/sound/formats/__init__.py"), baseDir)).isEqualTo("sound.formats");
-    assertThat(pythonPackageName(new File(baseDir, "packages/sound/formats/wavread.py"), baseDir)).isEqualTo("sound.formats");
-  }
-
   @Test
   void package_name_with_package_roots_namespace_packages() {
     // Test namespace packages (PEP 420) with package roots
@@ -82,17 +76,17 @@ void package_name_with_package_roots_namespace_packages() {
     List packageRoots = List.of(srcRoot);
 
     // File in namespace package (acme and math have no __init__.py, stats has __init__.py)
-    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/__init__.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/__init__.py"), packageRoots))
       .isEqualTo("acme.math.stats");
-    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/mean.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/mean.py"), packageRoots))
       .isEqualTo("acme.math.stats");
-    assertThat(pythonPackageName(new File(srcRoot, "acme/math/basic/__init__.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "acme/math/basic/__init__.py"), packageRoots))
       .isEqualTo("acme.math.basic");
 
     // File in regular package (mathlib has __init__.py)
-    assertThat(pythonPackageName(new File(srcRoot, "mathlib/__init__.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "mathlib/__init__.py"), packageRoots))
       .isEqualTo("mathlib");
-    assertThat(pythonPackageName(new File(srcRoot, "mathlib/utils/__init__.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "mathlib/utils/__init__.py"), packageRoots))
       .isEqualTo("mathlib.utils");
   }
 
@@ -104,33 +98,35 @@ void package_name_with_package_roots_file_at_root() {
 
     // A file directly in the package root should have empty package name
     File fileAtRoot = new File(srcRoot, "module.py");
-    assertThat(pythonPackageName(fileAtRoot, packageRoots, baseDir)).isEmpty();
+    assertThat(pythonPackageName(fileAtRoot, packageRoots)).isEmpty();
+  }
+
+  @Test
+  void package_name_with_resolved_root_file_at_root(@TempDir Path tempDir) throws IOException {
+    File fileAtRoot = Files.createFile(tempDir.resolve("module.py")).toFile();
+
+    assertThat(pythonPackageName(fileAtRoot, List.of(tempDir.toRealPath()))).isEmpty();
   }
 
   @Test
-  void package_name_with_package_roots_fallback_to_legacy() {
-    // When file is not under any package root, should fall back to __init__.py detection
+  void package_name_with_package_roots_file_not_under_any_root_returns_empty() {
+    // When file is not under any declared root, return empty string (no fallback)
     String baseDir = new File("src/test/resources").getAbsoluteFile().getAbsolutePath();
     String unrelatedRoot = new File(baseDir, "nonexistent").getAbsolutePath();
     List packageRoots = List.of(unrelatedRoot);
 
-    // File is not under the package root, so fallback to legacy detection
-    assertThat(pythonPackageName(new File(baseDir, "packages/sound/__init__.py"), packageRoots, baseDir))
-      .isEqualTo("sound");
-    assertThat(pythonPackageName(new File(baseDir, "packages/sound/formats/wavread.py"), packageRoots, baseDir))
-      .isEqualTo("sound.formats");
+    assertThat(pythonPackageName(new File(baseDir, "packages/sound/__init__.py"), packageRoots)).isEmpty();
+    assertThat(pythonPackageName(new File(baseDir, "packages/sound/formats/wavread.py"), packageRoots)).isEmpty();
   }
 
   @Test
-  void package_name_with_empty_package_roots_uses_legacy() {
-    // Empty package roots should fall back to legacy __init__.py detection
+  void package_name_with_empty_package_roots_returns_empty() {
+    // Empty package roots: no root can match, so empty string is returned
     String baseDir = new File("src/test/resources").getAbsoluteFile().getAbsolutePath();
     List packageRoots = List.of();
 
-    assertThat(pythonPackageName(new File(baseDir, "packages/sound/__init__.py"), packageRoots, baseDir))
-      .isEqualTo("sound");
-    assertThat(pythonPackageName(new File(baseDir, "packages/sound/formats/wavread.py"), packageRoots, baseDir))
-      .isEqualTo("sound.formats");
+    assertThat(pythonPackageName(new File(baseDir, "packages/sound/__init__.py"), packageRoots)).isEmpty();
+    assertThat(pythonPackageName(new File(baseDir, "packages/sound/formats/wavread.py"), packageRoots)).isEmpty();
   }
 
   @Test
@@ -141,11 +137,11 @@ void package_name_with_multiple_package_roots() {
     List packageRoots = List.of(packagesRoot, namespaceRoot);
 
     // File in first root
-    assertThat(pythonPackageName(new File(packagesRoot, "sound/__init__.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(packagesRoot, "sound/__init__.py"), packageRoots))
       .isEqualTo("sound");
 
     // File in second root
-    assertThat(pythonPackageName(new File(namespaceRoot, "acme/math/stats/__init__.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(namespaceRoot, "acme/math/stats/__init__.py"), packageRoots))
       .isEqualTo("acme.math.stats");
   }
 
@@ -155,10 +151,10 @@ void package_name_with_package_roots_edge_case_single_directory() {
     String srcRoot = new File(baseDir, "src").getAbsolutePath();
     List packageRoots = List.of(srcRoot);
 
-    assertThat(pythonPackageName(new File(srcRoot, "mathlib/__init__.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "mathlib/__init__.py"), packageRoots))
       .isEqualTo("mathlib");
 
-    assertThat(pythonPackageName(new File(srcRoot, "mathlib/utils.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "mathlib/utils.py"), packageRoots))
       .isEqualTo("mathlib");
   }
 
@@ -169,8 +165,7 @@ void package_name_with_package_roots_parent_not_under_root() {
     List packageRoots = List.of(unrelatedRoot);
 
     File fileOutsideRoot = new File(baseDir, "packages/sound/__init__.py");
-    assertThat(pythonPackageName(fileOutsideRoot, packageRoots, baseDir))
-      .isEqualTo("sound");
+    assertThat(pythonPackageName(fileOutsideRoot, packageRoots)).isEmpty();
   }
 
   @Test
@@ -178,14 +173,39 @@ void package_name_with_package_roots_trailing_separator() {
     String baseDir = new File("src/test/resources/namespace_packages").getAbsoluteFile().getAbsolutePath();
     String srcRoot = new File(baseDir, "src").getAbsolutePath();
     List packageRootsWithSeparator = List.of(srcRoot + File.separator);
-    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/mean.py"), packageRootsWithSeparator, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/mean.py"), packageRootsWithSeparator))
       .isEqualTo("acme.math.stats");
 
     List packageRootsWithoutSeparator = List.of(srcRoot);
-    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/mean.py"), packageRootsWithoutSeparator, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/mean.py"), packageRootsWithoutSeparator))
+      .isEqualTo("acme.math.stats");
+  }
+
+  @Test
+  void package_name_resolves_equivalent_root_paths() {
+    File baseDir = new File("src/test/resources/namespace_packages").getAbsoluteFile();
+    String equivalentSrcRoot = new File(baseDir, "src/../src").getPath();
+
+    assertThat(pythonPackageName(new File(baseDir, "src/acme/math/stats/mean.py"), List.of(equivalentSrcRoot)))
       .isEqualTo("acme.math.stats");
   }
 
+  @Test
+  void package_name_resolves_symbolic_link_alias(@TempDir Path tempDir) throws IOException {
+    Path realRoot = Files.createDirectories(tempDir.resolve("real/src"));
+    Path module = Files.createDirectories(realRoot.resolve("acme/math")).resolve("module.py");
+    Files.writeString(module, "");
+    Path alias = tempDir.resolve("alias");
+    try {
+      Files.createSymbolicLink(alias, tempDir.resolve("real"));
+    } catch (UnsupportedOperationException | IOException | SecurityException e) {
+      Assumptions.assumeTrue(false, "Symbolic links are not available: " + e.getMessage());
+    }
+
+    assertThat(pythonPackageName(alias.resolve("src/acme/math/module.py").toFile(), List.of(realRoot.toString())))
+      .isEqualTo("acme.math");
+  }
+
   @Test
   void package_name_with_package_roots_nested_subdirectories() {
     String baseDir = new File("src/test/resources/namespace_packages").getAbsoluteFile().getAbsolutePath();
@@ -193,12 +213,12 @@ void package_name_with_package_roots_nested_subdirectories() {
     List packageRoots = List.of(srcRoot);
 
     File deeplyNestedFile = new File(srcRoot, "acme/math/stats/mean.py");
-    assertThat(pythonPackageName(deeplyNestedFile, packageRoots, baseDir))
+    assertThat(pythonPackageName(deeplyNestedFile, packageRoots))
       .isEqualTo("acme.math.stats");
 
-    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/__init__.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "acme/math/stats/__init__.py"), packageRoots))
       .isEqualTo("acme.math.stats");
-    assertThat(pythonPackageName(new File(srcRoot, "mathlib/utils/__init__.py"), packageRoots, baseDir))
+    assertThat(pythonPackageName(new File(srcRoot, "mathlib/utils/__init__.py"), packageRoots))
       .isEqualTo("mathlib.utils");
   }
 
@@ -209,7 +229,7 @@ void package_name_with_package_roots_various_path_separators() {
     List packageRoots = List.of(srcRoot);
 
     File fileWithSlash = new File(srcRoot, "acme/math/basic/__init__.py");
-    String packageName = pythonPackageName(fileWithSlash, packageRoots, baseDir);
+    String packageName = pythonPackageName(fileWithSlash, packageRoots);
 
     assertThat(packageName).isEqualTo("acme.math.basic").doesNotContain("/").doesNotContain("\\");
   }
@@ -223,8 +243,8 @@ void package_name_with_package_roots_empty_package_name_for_root_files() {
     File rootFile1 = new File(srcRoot, "script.py");
     File rootFile2 = new File(srcRoot, "main.py");
 
-    assertThat(pythonPackageName(rootFile1, packageRoots, baseDir)).isEmpty();
-    assertThat(pythonPackageName(rootFile2, packageRoots, baseDir)).isEmpty();
+    assertThat(pythonPackageName(rootFile1, packageRoots)).isEmpty();
+    assertThat(pythonPackageName(rootFile2, packageRoots)).isEmpty();
   }
 
   @Test
@@ -235,11 +255,11 @@ void package_name_with_package_roots_priority_order() {
 
     List packageRoots1 = List.of(soundRoot, packagesRoot);
     File soundFormatFile = new File(soundRoot, "formats/__init__.py");
-    assertThat(pythonPackageName(soundFormatFile, packageRoots1, baseDir))
+    assertThat(pythonPackageName(soundFormatFile, packageRoots1))
       .isEqualTo("formats");
 
     List packageRoots2 = List.of(packagesRoot);
-    assertThat(pythonPackageName(soundFormatFile, packageRoots2, baseDir))
+    assertThat(pythonPackageName(soundFormatFile, packageRoots2))
       .isEqualTo("sound.formats");
   }
 
@@ -254,17 +274,17 @@ void fqn_by_package_with_subpackage() {
 
   @Test
   void path_of() throws IOException, URISyntaxException {
-    PythonFile pythonFile = Mockito.mock(PythonFile.class);
+    PythonFile pythonFile = mock(PythonFile.class);
     URI uri = Files.createTempFile("foo.py", "py").toUri();
-    Mockito.when(pythonFile.uri()).thenReturn(uri);
+    when(pythonFile.uri()).thenReturn(uri);
     assertThat(pathOf(pythonFile)).isEqualTo(Paths.get(uri));
 
     uri = new URI("myscheme", null, "/file1.py", null);
 
-    Mockito.when(pythonFile.uri()).thenReturn(uri);
+    when(pythonFile.uri()).thenReturn(uri);
     assertThat(pathOf(pythonFile)).isNull();
 
-    Mockito.when(pythonFile.uri()).thenThrow(InvalidPathException.class);
+    when(pythonFile.uri()).thenThrow(InvalidPathException.class);
     assertThat(pathOf(pythonFile)).isNull();
   }
 
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/UsageImplTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/UsageImplTest.java
index 1125c7fb3a..3813708299 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/UsageImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/UsageImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,11 +17,11 @@
 package org.sonar.python.semantic;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.symbols.Usage;
 import org.sonar.plugins.python.api.tree.Tree;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 
 class UsageImplTest {
@@ -39,7 +39,7 @@ void binding_usages() {
   }
 
   private static void assertBindingUsage(Usage.Kind kind, boolean isBinding) {
-    Tree mockTree = Mockito.mock(Tree.class);
+    Tree mockTree = mock(Tree.class);
     UsageImpl usage = new UsageImpl(mockTree, kind);
     assertThat(usage.kind()).isEqualTo(kind);
     assertThat(usage.isBindingUsage()).isEqualTo(isBinding);
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2Test.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2Test.java
index 6f7e9277b8..227ca9bf67 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2Test.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolTableBuilderV2Test.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,12 +22,15 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.sonar.plugins.python.api.symbols.v2.SymbolV2;
+import org.sonar.plugins.python.api.symbols.v2.UsageV2;
 import org.sonar.plugins.python.api.tree.AssignmentStatement;
+import org.sonar.plugins.python.api.tree.ClassDef;
 import org.sonar.plugins.python.api.tree.FileInput;
 import org.sonar.plugins.python.api.tree.FunctionDef;
 import org.sonar.plugins.python.api.tree.ImportName;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.TypeAliasStatement;
 import org.sonar.python.PythonTestUtils;
 import org.sonar.python.tree.TreeUtils;
 
@@ -260,6 +263,33 @@ void never_written_variables_have_symbol() {
   }
 
 
+  @Test
+  void class_type_param_bound_is_resolved_in_enclosing_scope() {
+    FileInput fileInput = PythonTestUtils.parse("""
+        class BaseBound:
+            pass
+        class Foo[T: BaseBound]:
+            pass
+        """);
+    new SymbolTableBuilderV2(fileInput).build();
+    ClassDef fooClass = (ClassDef) fileInput.statements().statements().get(1);
+    Name boundName = (Name) fooClass.typeParams().typeParamsList().get(0).typeAnnotation().expression();
+    Assertions.assertThat(boundName.symbolV2()).isNotNull();
+    Assertions.assertThat(boundName.symbolV2().name()).isEqualTo("BaseBound");
+  }
+
+  @Test
+  void type_alias_type_params_are_registered() {
+    FileInput fileInput = PythonTestUtils.parse("type Alias[T] = list[T]");
+    new SymbolTableBuilderV2(fileInput).build();
+    TypeAliasStatement typeAlias = (TypeAliasStatement) fileInput.statements().statements().get(0);
+    Name typeParamName = typeAlias.typeParams().typeParamsList().get(0).name();
+    Assertions.assertThat(typeParamName.symbolV2()).isNotNull();
+    Assertions.assertThat(typeParamName.symbolV2().usages())
+      .extracting(UsageV2::kind)
+      .contains(UsageV2.Kind.TYPE_PARAM_DECLARATION);
+  }
+
   private static void assertNameSymbol(Name name, String expectedSymbolName, int expectedUsagesCount) {
     var symbol = name.symbolV2();
     Assertions.assertThat(symbol).isNotNull();
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolV2ImplTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolV2ImplTest.java
index b2657c2c5b..7c46d06e3f 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolV2ImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolV2ImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolV2UtilsTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolV2UtilsTest.java
index 1fb3345c67..8010720cc9 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolV2UtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/SymbolV2UtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/TestProject.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/TestProject.java
index 42d5a463bd..54910abcfe 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/TestProject.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/TestProject.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeCheckerBuilderTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeCheckerBuilderTest.java
index 89283af970..792db13f9e 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeCheckerBuilderTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeCheckerBuilderTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeInferenceV2Test.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeInferenceV2Test.java
index af6bb598cc..57714ddca5 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeInferenceV2Test.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeInferenceV2Test.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -33,7 +33,6 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.LocationInFile;
 import org.sonar.plugins.python.api.PythonFile;
 import org.sonar.plugins.python.api.PythonVisitorContext;
@@ -84,6 +83,7 @@
 import org.sonar.python.semantic.ProjectLevelSymbolTable;
 import org.sonar.python.semantic.SymbolUtils;
 import org.sonar.python.semantic.v2.typetable.ProjectLevelTypeTable;
+import org.sonar.python.semantic.v2.typeshed.TypeShedConstants;
 import org.sonar.python.tree.ExpressionStatementImpl;
 import org.sonar.python.tree.TreeUtils;
 import org.sonar.python.tree.TupleImpl;
@@ -98,6 +98,7 @@
 import static org.sonar.python.PythonTestUtils.parseWithoutSymbols;
 import static org.sonar.python.PythonTestUtils.pythonFile;
 import static org.sonar.python.types.v2.TypesTestUtils.BOOL_TYPE;
+import static org.sonar.python.types.v2.TypesTestUtils.BYTES_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.DICT_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.EXCEPTION_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.FLOAT_TYPE;
@@ -110,6 +111,10 @@
 import static org.sonar.python.types.v2.TypesTestUtils.STR_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.TUPLE_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.TYPE_TYPE;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
 
 public class TypeInferenceV2Test {
 
@@ -3126,15 +3131,15 @@ void return_type_of_call_expression_inconsistent() {
         """
     );
     CallExpression callExpression = ((CallExpression) ((ExpressionStatement) fileInput.statements().statements().get(0)).expressions().get(0));
-    CallExpression callExpressionSpy = Mockito.spy(callExpression);
+    CallExpression callExpressionSpy = spy(callExpression);
 
     // Inconsistent union type, should not happen
-    UnionType unionType = Mockito.mock(UnionType.class);
-    Mockito.when(unionType.candidates()).thenReturn(Set.of(PythonType.UNKNOWN));
+    UnionType unionType = mock(UnionType.class);
+    when(unionType.candidates()).thenReturn(Set.of(PythonType.UNKNOWN));
 
-    Name mock = Mockito.mock(Name.class);
-    Mockito.when(mock.typeV2()).thenReturn(unionType);
-    Mockito.doReturn(mock).when(callExpressionSpy).callee();
+    Name mock = mock(Name.class);
+    when(mock.typeV2()).thenReturn(unionType);
+    doReturn(mock).when(callExpressionSpy).callee();
 
     assertThat(callExpressionSpy.typeV2()).isEqualTo(PythonType.UNKNOWN);
   }
@@ -3147,15 +3152,15 @@ void return_type_of_call_expression_inconsistent_2() {
         """
     );
     CallExpression callExpression = ((CallExpression) ((ExpressionStatement) fileInput.statements().statements().get(0)).expressions().get(0));
-    CallExpression callExpressionSpy = Mockito.spy(callExpression);
+    CallExpression callExpressionSpy = spy(callExpression);
 
     // Inconsistent union type, should not happen
-    UnionType unionType = Mockito.mock(UnionType.class);
-    Mockito.when(unionType.candidates()).thenReturn(Set.of());
+    UnionType unionType = mock(UnionType.class);
+    when(unionType.candidates()).thenReturn(Set.of());
 
-    Name mock = Mockito.mock(Name.class);
-    Mockito.when(mock.typeV2()).thenReturn(unionType);
-    Mockito.doReturn(mock).when(callExpressionSpy).callee();
+    Name mock = mock(Name.class);
+    when(mock.typeV2()).thenReturn(unionType);
+    doReturn(mock).when(callExpressionSpy).callee();
 
     assertThat(callExpressionSpy.typeV2()).isEqualTo(PythonType.UNKNOWN);
   }
@@ -3273,8 +3278,8 @@ void resolveIncorrectLazyType2() {
     ModuleType builtinModule = symbolsModuleTypeProvider.getRootModule();
     symbolsModuleTypeProvider.convertModuleType(List.of("typing"), builtinModule);
 
-    ClassSymbol symbol = Mockito.mock(ClassSymbolImpl.class);
-    Mockito.when(symbol.kind()).thenReturn(Symbol.Kind.OTHER);
+    ClassSymbol symbol = mock(ClassSymbolImpl.class);
+    when(symbol.kind()).thenReturn(Symbol.Kind.OTHER);
     assertThat(PROJECT_LEVEL_TYPE_TABLE.lazyTypesContext().getOrCreateLazyType("typing.Iterable.unknown").resolve()).isEqualTo(PythonType.UNKNOWN);
   }
 
@@ -3351,12 +3356,36 @@ void import_conflict_between_member_and_submodule() {
   }
 
   @Test
-  void import_unknown_httpx_client() {
+  void import_httpx_client() {
     var statement = lastExpression("""
       import httpx
       httpx.Client()
       """);
-    assertThat(statement.typeV2()).isEqualTo(PythonType.UNKNOWN);
+    PythonType clientType = PROJECT_LEVEL_TYPE_TABLE.getType("httpx.Client");
+    assertThat(clientType).isNotEqualTo(PythonType.UNKNOWN);
+    assertThat(statement.typeV2()).is(TypesTestUtils.objectTypeOf(clientType));
+  }
+
+  @Test
+  void import_httpx_async_client() {
+    var statement = lastExpression("""
+      import httpx
+      httpx.AsyncClient()
+      """);
+    PythonType asyncClientType = PROJECT_LEVEL_TYPE_TABLE.getType("httpx.AsyncClient");
+    assertThat(asyncClientType).isNotEqualTo(PythonType.UNKNOWN);
+    assertThat(statement.typeV2()).is(TypesTestUtils.objectTypeOf(asyncClientType));
+  }
+
+  @Test
+  void import_confluent_kafka_aio_consumer() {
+    var statement = lastExpression("""
+      from confluent_kafka.aio import AIOConsumer
+      AIOConsumer({})
+      """);
+    PythonType aioConsumerType = PROJECT_LEVEL_TYPE_TABLE.getType("confluent_kafka.aio.AIOConsumer");
+    assertThat(aioConsumerType).isNotEqualTo(PythonType.UNKNOWN);
+    assertThat(statement.typeV2()).is(TypesTestUtils.objectTypeOf(aioConsumerType));
   }
 
   @Test
@@ -3630,6 +3659,34 @@ def foo(x):
     assertThat(cType).isSameAs(PythonType.UNKNOWN);
   }
 
+  @Test
+  void assignmentBytesLiteral() {
+    // A bytes literal (b"...") used to be typed as `str`: visitStringLiteral didn't check the
+    // literal's prefix before resolving it against the builtin `str` type.
+    var fileInput = inferTypes("""
+      def foo():
+        a = b""
+        b = b"abc"
+        c = ""
+        a
+        b
+        c
+      """);
+
+    var statements = TreeUtils.firstChild(fileInput, FunctionDef.class::isInstance)
+      .map(FunctionDef.class::cast)
+      .map(FunctionDef::body)
+      .map(StatementList::statements)
+      .orElseGet(List::of);
+
+    var aType = ((ExpressionStatement) statements.get(statements.size() - 3)).expressions().get(0).typeV2();
+    var bType = ((ExpressionStatement) statements.get(statements.size() - 2)).expressions().get(0).typeV2();
+    var cType = ((ExpressionStatement) statements.get(statements.size() - 1)).expressions().get(0).typeV2();
+    assertThat(aType.unwrappedType()).isSameAs(BYTES_TYPE);
+    assertThat(bType.unwrappedType()).isSameAs(BYTES_TYPE);
+    assertThat(cType.unwrappedType()).isSameAs(STR_TYPE);
+  }
+
   @Test
   void assignmentMinusTest() {
     var fileInput = inferTypes("""
@@ -4041,8 +4098,10 @@ void reexportedWildcardImport() {
     var actualFoo = tupleExpr.elements().get(1);
 
     assertThat(importedFoo.typeV2())
-      .isEqualTo(PythonType.UNKNOWN)
+      .isInstanceOf(UnknownType.UnresolvedImportType.class)
       .isNotEqualTo(actualFoo.typeV2());
+    assertThat(((UnknownType.UnresolvedImportType) importedFoo.typeV2()).importPath())
+      .isEqualTo("mod2.foo");
   }
 
   @Test
@@ -4178,6 +4237,21 @@ private static FileInput inferTypes(String lines) {
     return inferTypes(lines, PROJECT_LEVEL_TYPE_TABLE);
   }
 
+  private static Name pytestRequestName(FileInput root) {
+    return PythonTestUtils.getLastDescendant(root, t -> t instanceof Name name && "request".equals(name.name()));
+  }
+
+  private static PythonType fixtureRequestType() {
+    return PROJECT_LEVEL_TYPE_TABLE.getType(TypeShedConstants.PYTEST_FIXTURE_REQUEST_FQN);
+  }
+
+  private static void assertRequestIsFixtureRequest(FileInput root) {
+    PythonType requestType = pytestRequestName(root).typeV2();
+    assertThat(requestType).isInstanceOf(ObjectType.class);
+    assertThat(fixtureRequestType()).isNotEqualTo(PythonType.UNKNOWN);
+    assertThat(((ObjectType) requestType).unwrappedType()).isEqualTo(fixtureRequestType());
+  }
+
   public static FileInput inferTypes(String lines, ProjectLevelTypeTable projectLevelTypeTable) {
     FileInput root = parse(lines);
 
@@ -4378,6 +4452,98 @@ def foo((a, b)):
     assertThat(fooMethodDef.name().typeV2()).isInstanceOf(FunctionType.class);
   }
 
+  @ParameterizedTest
+  @MethodSource("pytestRequestParameterTypedWithPytestImportSource")
+  void pytestRequestParameterIsTypedWithPytestImport(String code) {
+    assertRequestIsFixtureRequest(inferTypes(code));
+  }
+
+  static Stream pytestRequestParameterTypedWithPytestImportSource() {
+    return Stream.of(
+      """
+      import pytest
+
+      def test_foo(request):
+        request
+      """,
+      """
+      from pytest import fixture
+
+      def test_foo(request):
+        request
+      """,
+      """
+      import pytest as pt
+
+      def test_foo(request):
+        request
+      """
+    );
+  }
+
+  @Test
+  void pytestRequestParameterIsNotTypedWithoutPytestImport() {
+    FileInput root = inferTypes("""
+      def test_foo(request):
+        request
+      """);
+
+    assertThat(pytestRequestName(root).typeV2()).isEqualTo(PythonType.UNKNOWN);
+  }
+
+  @Test
+  void pytestRequestParameterKeepsExplicitAnnotation() {
+    FileInput root = inferTypes("""
+      import pytest
+
+      def test_foo(request: str):
+        request
+      """);
+
+    assertThat(pytestRequestName(root).typeV2()).is(TypesTestUtils.objectTypeOf(PROJECT_LEVEL_TYPE_TABLE.getType("builtins.str")));
+  }
+
+  @Test
+  void pytestRequestParameterIsNotTypedForOtherParameterNames() {
+    FileInput root = inferTypes("""
+      import pytest
+
+      def test_foo(other):
+        other
+      """);
+
+    Name otherName = PythonTestUtils.getLastDescendant(root, t -> t instanceof Name name && "other".equals(name.name()));
+    assertThat(otherName.typeV2()).isEqualTo(PythonType.UNKNOWN);
+  }
+
+  @Test
+  void pytestRequestParameterIsTypedInFixtureFunction() {
+    FileInput root = inferTypes("""
+      import pytest
+
+      @pytest.fixture
+      def my_fixture(request):
+        request
+      """);
+
+    assertThat(((ObjectType) pytestRequestName(root).typeV2()).unwrappedType()).isEqualTo(fixtureRequestType());
+  }
+
+  @Test
+  void pytestRequestParameterIsNotTypedWhenFixtureRequestTypeUnknown() {
+    ProjectLevelTypeTable typeTable = spy(PROJECT_LEVEL_TYPE_TABLE);
+    doReturn(PythonType.UNKNOWN).when(typeTable).getType(TypeShedConstants.PYTEST_FIXTURE_REQUEST_FQN);
+
+    FileInput root = inferTypes("""
+      import pytest
+
+      def test_foo(request):
+        request
+      """, typeTable);
+
+    assertThat(pytestRequestName(root).typeV2()).isEqualTo(PythonType.UNKNOWN);
+  }
+
   @Test
   void inferParameterTypeHintedWithTypingSelf() {
     FileInput root = inferTypes("""
@@ -5186,4 +5352,156 @@ class Foo:
       .element(0)
       .is(TypesTestUtils.objectTypeOf(projectLevelIntType));
   }
+
+  @Test
+  void superCallMemberResolvesFromBaseClass() {
+    // super() inside a method should resolve members from the superclass hierarchy,
+    // not from the builtin super class itself.
+    FileInput root = inferTypes("""
+      class Base:
+        def my_method(self, p1, p2): pass
+      class A(Base):
+        def foo(self):
+          super().my_method(1, 2)
+      """);
+
+    // super().my_method should resolve to Base.my_method
+    // Find the qualified expression super().my_method
+    List qualifiedExprs = PythonTestUtils.getAllDescendant(root, t -> t.is(Tree.Kind.QUALIFIED_EXPR));
+    QualifiedExpression superMyMethod = qualifiedExprs.stream()
+      .filter(qe -> "my_method".equals(qe.name().name()))
+      .findFirst()
+      .orElseThrow(() -> new AssertionError("Could not find super().my_method qualified expression"));
+
+    PythonType memberType = superMyMethod.name().typeV2();
+
+    // The member should be a FunctionType for Base.my_method
+    assertThat(memberType).isInstanceOf(FunctionType.class);
+    FunctionType functionType = (FunctionType) memberType;
+    assertThat(functionType.fullyQualifiedName()).isEqualTo("my_package.mod.Base.my_method");
+  }
+
+  @Test
+  void superCallAssignedVariableMemberResolvesFromBaseClass() {
+    // s = super(); s.my_method should also resolve to the base class member
+    FileInput root = inferTypes("""
+      class Base:
+        def my_method(self, p1, p2): pass
+      class A(Base):
+        def foo(self):
+          s = super()
+          s.my_method(1, 2)
+      """);
+
+    // Find s.my_method qualified expression
+    List qualifiedExprs = PythonTestUtils.getAllDescendant(root, t -> t.is(Tree.Kind.QUALIFIED_EXPR));
+    QualifiedExpression sMyMethod = qualifiedExprs.stream()
+      .filter(qe -> "my_method".equals(qe.name().name()))
+      .findFirst()
+      .orElseThrow(() -> new AssertionError("Could not find s.my_method qualified expression"));
+
+    PythonType memberType = sMyMethod.name().typeV2();
+
+    assertThat(memberType).isInstanceOf(FunctionType.class);
+    FunctionType functionType = (FunctionType) memberType;
+    assertThat(functionType.fullyQualifiedName()).isEqualTo("my_package.mod.Base.my_method");
+  }
+
+  @Test
+  void superCallDoesNotResolveChildClassOnlyMethods() {
+    FileInput root = inferTypes("""
+      class Base:
+        def base_method(self): pass
+      class A(Base):
+        def foo(self):
+          super().child_only_method
+        def child_only_method(self): pass
+      """);
+
+    List qualifiedExprs = PythonTestUtils.getAllDescendant(root, t -> t.is(Tree.Kind.QUALIFIED_EXPR));
+    QualifiedExpression superChildOnlyMethod = qualifiedExprs.stream()
+      .filter(qe -> "child_only_method".equals(qe.name().name()))
+      .findFirst()
+      .orElseThrow(() -> new AssertionError("Could not find super().child_only_method qualified expression"));
+
+    assertThat(superChildOnlyMethod.name().typeV2()).isEqualTo(PythonType.UNKNOWN);
+  }
+
+  @Test
+  void superCallInClassMethodResolvesFromBaseClass() {
+    FileInput root = inferTypes("""
+      class Base:
+        def base_method(self): pass
+      class A(Base):
+        @classmethod
+        def foo(cls):
+          super().base_method
+      """);
+
+    List qualifiedExprs = PythonTestUtils.getAllDescendant(root, t -> t.is(Tree.Kind.QUALIFIED_EXPR));
+    QualifiedExpression superBaseMethod = qualifiedExprs.stream()
+      .filter(qe -> "base_method".equals(qe.name().name()))
+      .findFirst()
+      .orElseThrow(() -> new AssertionError("Could not find super().base_method qualified expression"));
+
+    PythonType memberType = superBaseMethod.name().typeV2();
+
+    assertThat(memberType).isInstanceOf(FunctionType.class);
+    FunctionType functionType = (FunctionType) memberType;
+    assertThat(functionType.fullyQualifiedName()).isEqualTo("my_package.mod.Base.base_method");
+  }
+
+  @Test
+  void superCallMemberResolvesFollowingMro() {
+    FileInput root = inferTypes("""
+      class O:
+        def target(self): pass
+      class X(O): pass
+      class Y(O):
+        def target(self): pass
+      class A(X, Y):
+        def foo(self):
+          super().target
+      """);
+
+    List qualifiedExprs = PythonTestUtils.getAllDescendant(root, t -> t.is(Tree.Kind.QUALIFIED_EXPR));
+    QualifiedExpression superTarget = qualifiedExprs.stream()
+      .filter(qe -> "target".equals(qe.name().name()))
+      .findFirst()
+      .orElseThrow(() -> new AssertionError("Could not find super().target qualified expression"));
+
+    PythonType memberType = superTarget.name().typeV2();
+
+    assertThat(memberType).isInstanceOf(FunctionType.class);
+    FunctionType functionType = (FunctionType) memberType;
+    assertThat(functionType.fullyQualifiedName()).isEqualTo("my_package.mod.Y.target");
+  }
+
+  @Test
+  void superCallMemberResolvesFollowingMroWhenYNotInheritingO() {
+    // Y does not inherit from O. MRO of A(X, Y) is [A, X, O, Y, object].
+    // super() in A skips A -> X (no target) -> O (has target) -> resolves O.target
+    FileInput root = inferTypes("""
+      class O:
+        def target(self): pass
+      class X(O): pass
+      class Y:
+        def target(self): pass
+      class A(X, Y):
+        def foo(self):
+          super().target
+      """);
+
+    List qualifiedExprs = PythonTestUtils.getAllDescendant(root, t -> t.is(Tree.Kind.QUALIFIED_EXPR));
+    QualifiedExpression superTarget = qualifiedExprs.stream()
+      .filter(qe -> "target".equals(qe.name().name()))
+      .findFirst()
+      .orElseThrow(() -> new AssertionError("Could not find super().target qualified expression"));
+
+    PythonType memberType = superTarget.name().typeV2();
+
+    assertThat(memberType).isInstanceOf(FunctionType.class);
+    FunctionType functionType = (FunctionType) memberType;
+    assertThat(functionType.fullyQualifiedName()).isEqualTo("my_package.mod.O.target");
+  }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphCollectorTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphCollectorTest.java
index 157488c481..803989aa97 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphCollectorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphCollectorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphIterableTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphIterableTest.java
index 5403ded2ce..527b2c8e33 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphIterableTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphIterableTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,7 +22,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class CallGraphIterableTest {
   @Test
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphNodeTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphNodeTest.java
index e032c13669..71397a7eaf 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphNodeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphNodeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphTest.java
index 2190ce6bdd..c5e7da95d4 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphWalkerTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphWalkerTest.java
index 1d32e8ba7f..809fdf24a4 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphWalkerTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/callgraph/CallGraphWalkerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/AmbiguousDescriptorToPythonTypeConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/AmbiguousDescriptorToPythonTypeConverterTest.java
index a533c1e60c..f208d63ce9 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/AmbiguousDescriptorToPythonTypeConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/AmbiguousDescriptorToPythonTypeConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,7 +19,6 @@
 import java.util.Set;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.python.index.AmbiguousDescriptor;
 import org.sonar.python.index.ClassDescriptor;
 import org.sonar.python.index.Descriptor;
@@ -28,13 +27,14 @@
 import org.sonar.python.types.v2.LazyUnionType;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 class AmbiguousDescriptorToPythonTypeConverterTest {
   @Test
   void unsupportedClassTest() {
-    var ctx = Mockito.mock(ConversionContext.class);
-    var descriptor = Mockito.mock(ClassDescriptor.class);
+    var ctx = mock(ConversionContext.class);
+    var descriptor = mock(ClassDescriptor.class);
     var converter = new AmbiguousDescriptorToPythonTypeConverter();
     Assertions.assertThatThrownBy(() -> converter.convert(ctx, descriptor))
       .isInstanceOf(IllegalArgumentException.class)
@@ -43,17 +43,17 @@ void unsupportedClassTest() {
 
   @Test
   void testDescriptorWithLazyTypes() {
-    var descriptor = Mockito.mock(Descriptor.class);
+    var descriptor = mock(Descriptor.class);
     when(descriptor.kind()).thenReturn(Descriptor.Kind.VARIABLE);
 
-    var descriptor2 = Mockito.mock(Descriptor.class);
+    var descriptor2 = mock(Descriptor.class);
     when(descriptor2.kind()).thenReturn(Descriptor.Kind.VARIABLE);
 
-    var lazyTypeContext = Mockito.mock(LazyTypesContext.class);
+    var lazyTypeContext = mock(LazyTypesContext.class);
     var lazyType1 = new LazyType("lazy1", lazyTypeContext);
     var lazyType2 = new LazyType("lazy2", lazyTypeContext);
 
-    var ctx = Mockito.mock(ConversionContext.class);
+    var ctx = mock(ConversionContext.class);
     when(ctx.convert(descriptor)).thenReturn(lazyType1);
     when(ctx.convert(descriptor2)).thenReturn(lazyType2);
 
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/ClassDescriptorToPythonTypeConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/ClassDescriptorToPythonTypeConverterTest.java
index ede3e5e846..44de39cb0f 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/ClassDescriptorToPythonTypeConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/ClassDescriptorToPythonTypeConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,7 +19,6 @@
 import java.util.Set;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.types.v2.ClassType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.plugins.python.api.types.v2.SelfType;
@@ -34,12 +33,13 @@
 import org.sonar.python.semantic.v2.typetable.ProjectLevelTypeTable;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 class ClassDescriptorToPythonTypeConverterTest {
   @Test
   void unsupportedClassTest() {
-    var ctx = Mockito.mock(ConversionContext.class);
-    var descriptor = Mockito.mock(FunctionDescriptor.class);
+    var ctx = mock(ConversionContext.class);
+    var descriptor = mock(FunctionDescriptor.class);
     var converter = new ClassDescriptorToPythonTypeConverter();
     Assertions.assertThatThrownBy(() -> converter.convert(ctx, descriptor))
       .isInstanceOf(IllegalArgumentException.class)
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/ConversionContextTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/ConversionContextTest.java
index 7ec495be7f..810a4b03bc 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/ConversionContextTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/ConversionContextTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,18 +18,20 @@
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.python.index.Descriptor;
 import org.sonar.python.semantic.v2.LazyTypesContext;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.plugins.python.api.types.v2.TypeOrigin;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
 class ConversionContextTest {
 
   @Test
   void lazyTypeContextTest() {
-    var expectedLazyTypeContext = Mockito.mock(LazyTypesContext.class);
-    var rootConverter = Mockito.mock(DescriptorToPythonTypeConverter.class);
+    var expectedLazyTypeContext = mock(LazyTypesContext.class);
+    var rootConverter = mock(DescriptorToPythonTypeConverter.class);
     var ctx = new ConversionContext("", expectedLazyTypeContext, rootConverter, TypeOrigin.LOCAL);
     var lazyTypesContext = ctx.lazyTypesContext();
     Assertions.assertSame(expectedLazyTypeContext, lazyTypesContext);
@@ -37,11 +39,11 @@ void lazyTypeContextTest() {
 
   @Test
   void parentsTest() {
-    var expectedLazyTypeContext = Mockito.mock(LazyTypesContext.class);
-    var rootConverter = Mockito.mock(DescriptorToPythonTypeConverter.class);
+    var expectedLazyTypeContext = mock(LazyTypesContext.class);
+    var rootConverter = mock(DescriptorToPythonTypeConverter.class);
     var ctx = new ConversionContext("", expectedLazyTypeContext, rootConverter, TypeOrigin.LOCAL);
-    var firstParent = Mockito.mock(PythonType.class);
-    var secondParent = Mockito.mock(PythonType.class);
+    var firstParent = mock(PythonType.class);
+    var secondParent = mock(PythonType.class);
 
     Assertions.assertNull(ctx.currentParent());
     ctx.pushParent(firstParent);
@@ -56,14 +58,14 @@ void parentsTest() {
 
   @Test
   void convertTest() {
-    var descriptor = Mockito.mock(Descriptor.class);
-    var expectedType = Mockito.mock(PythonType.class);
+    var descriptor = mock(Descriptor.class);
+    var expectedType = mock(PythonType.class);
 
-    var lazyTypeContext = Mockito.mock(LazyTypesContext.class);
-    var rootConverter = Mockito.mock(DescriptorToPythonTypeConverter.class);
+    var lazyTypeContext = mock(LazyTypesContext.class);
+    var rootConverter = mock(DescriptorToPythonTypeConverter.class);
     var ctx = new ConversionContext("", lazyTypeContext, rootConverter, TypeOrigin.LOCAL);
 
-    Mockito.when(rootConverter.convert(ctx, descriptor))
+    when(rootConverter.convert(ctx, descriptor))
       .thenReturn(expectedType);
 
     var type = ctx.convert(descriptor);
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/DescriptorToPythonTypeConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/DescriptorToPythonTypeConverterTest.java
index 722f1f54ce..7f8aeb1c2c 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/DescriptorToPythonTypeConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/DescriptorToPythonTypeConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,7 +20,6 @@
 import java.util.Set;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.LocationInFile;
 import org.sonar.python.index.AmbiguousDescriptor;
 import org.sonar.python.index.ClassDescriptor;
@@ -42,13 +41,17 @@
 import org.sonar.plugins.python.api.types.v2.TypeWrapper;
 import org.sonar.plugins.python.api.types.v2.UnionType;
 
+import static org.mockito.Mockito.argThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
 class DescriptorToPythonTypeConverterTest {
 
   @Test
   void unknownDescriptorToPythonTypeConverterTest() {
-    var ctx = Mockito.mock(ConversionContext.class);
-    var descriptor = Mockito.mock(Descriptor.class);
-    Mockito.when(descriptor.kind()).thenReturn(null);
+    var ctx = mock(ConversionContext.class);
+    var descriptor = mock(Descriptor.class);
+    when(descriptor.kind()).thenReturn(null);
     var converter = new UnknownDescriptorToPythonTypeConverter();
     var type = converter.convert(ctx, descriptor);
     Assertions.assertThat(type).isEqualTo(PythonType.UNKNOWN);
@@ -56,21 +59,21 @@ void unknownDescriptorToPythonTypeConverterTest() {
 
   @Test
   void ambiguousDescriptorConversionTest() {
-    var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
+    var lazyTypesContext = mock(LazyTypesContext.class);
     var converter = new AnyDescriptorToPythonTypeConverter(lazyTypesContext);
 
-    var descriptorAlternative1 = Mockito.mock(FunctionDescriptor.class);
+    var descriptorAlternative1 = mock(FunctionDescriptor.class);
 
     var returnTypeName = "Returned";
     String fullyQualifiedName = "returned.ReturnTypeName";
     var resolvedReturnType = new ClassTypeBuilder(returnTypeName, fullyQualifiedName).build();
-    Mockito.when(lazyTypesContext.resolveLazyType(Mockito.argThat(lt -> returnTypeName.equals(lt.importPath()))))
+    when(lazyTypesContext.resolveLazyType(argThat(lt -> returnTypeName.equals(lt.importPath()))))
       .thenReturn(resolvedReturnType);
 
-    Mockito.when(descriptorAlternative1.kind()).thenReturn(Descriptor.Kind.FUNCTION);
-    Mockito.when(descriptorAlternative1.name()).thenReturn("Sample");
-    Mockito.when(descriptorAlternative1.annotatedReturnTypeName()).thenReturn(returnTypeName);
-    Mockito.when(descriptorAlternative1.parameters()).thenReturn(List.of(
+    when(descriptorAlternative1.kind()).thenReturn(Descriptor.Kind.FUNCTION);
+    when(descriptorAlternative1.name()).thenReturn("Sample");
+    when(descriptorAlternative1.annotatedReturnTypeName()).thenReturn(returnTypeName);
+    when(descriptorAlternative1.parameters()).thenReturn(List.of(
       new FunctionDescriptor.Parameter(
         "p1",
         "Returned",
@@ -83,11 +86,11 @@ void ambiguousDescriptorConversionTest() {
         new LocationInFile("m1", 1, 10,  1, 15))
     ));
 
-    var descriptorAlternative2 = Mockito.mock(FunctionDescriptor.class);
-    Mockito.when(descriptorAlternative2.kind()).thenReturn(Descriptor.Kind.FUNCTION);
-    Mockito.when(descriptorAlternative2.name()).thenReturn("Sample");
-    Mockito.when(descriptorAlternative2.annotatedReturnTypeName()).thenReturn(returnTypeName);
-    Mockito.when(descriptorAlternative2.parameters()).thenReturn(List.of(
+    var descriptorAlternative2 = mock(FunctionDescriptor.class);
+    when(descriptorAlternative2.kind()).thenReturn(Descriptor.Kind.FUNCTION);
+    when(descriptorAlternative2.name()).thenReturn("Sample");
+    when(descriptorAlternative2.annotatedReturnTypeName()).thenReturn(returnTypeName);
+    when(descriptorAlternative2.parameters()).thenReturn(List.of(
       new FunctionDescriptor.Parameter(
         "p2",
         "Returned",
@@ -100,9 +103,9 @@ void ambiguousDescriptorConversionTest() {
         new LocationInFile("m1", 2, 10,  2, 15))
     ));
 
-    var descriptor = Mockito.mock(AmbiguousDescriptor.class);
-    Mockito.when(descriptor.kind()).thenReturn(Descriptor.Kind.AMBIGUOUS);
-    Mockito.when(descriptor.alternatives()).thenReturn(Set.of(descriptorAlternative1, descriptorAlternative2));
+    var descriptor = mock(AmbiguousDescriptor.class);
+    when(descriptor.kind()).thenReturn(Descriptor.Kind.AMBIGUOUS);
+    when(descriptor.alternatives()).thenReturn(Set.of(descriptorAlternative1, descriptorAlternative2));
 
     var type = (UnionType) converter.convert("", descriptor, TypeOrigin.LOCAL);
     Assertions.assertThat(type.candidates())
@@ -118,28 +121,28 @@ void ambiguousDescriptorConversionTest() {
 
   @Test
   void classDescriptorConversionTest() {
-    var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
+    var lazyTypesContext = mock(LazyTypesContext.class);
     var converter = new AnyDescriptorToPythonTypeConverter(lazyTypesContext);
-    var descriptor = Mockito.mock(ClassDescriptor.class);
+    var descriptor = mock(ClassDescriptor.class);
 
     var parentClassName = "Parent";
     String parentClassFqn = "parent.Parent";
     var resolvedParent = new ClassTypeBuilder(parentClassName, parentClassFqn).build();
 
-    var member = Mockito.mock(AmbiguousDescriptor.class);
-    Mockito.when(member.kind()).thenReturn(Descriptor.Kind.AMBIGUOUS);
-    Mockito.when(member.name()).thenReturn("member");
+    var member = mock(AmbiguousDescriptor.class);
+    when(member.kind()).thenReturn(Descriptor.Kind.AMBIGUOUS);
+    when(member.name()).thenReturn("member");
 
-    Mockito.when(descriptor.kind()).thenReturn(Descriptor.Kind.CLASS);
-    Mockito.when(descriptor.name()).thenReturn("Sample");
-    Mockito.when(descriptor.superClasses()).thenReturn(List.of(parentClassName));
-    Mockito.when(descriptor.members()).thenReturn(List.of(
+    when(descriptor.kind()).thenReturn(Descriptor.Kind.CLASS);
+    when(descriptor.name()).thenReturn("Sample");
+    when(descriptor.superClasses()).thenReturn(List.of(parentClassName));
+    when(descriptor.members()).thenReturn(List.of(
       member
     ));
-    Mockito.when(lazyTypesContext.getOrCreateLazyType(parentClassName))
+    when(lazyTypesContext.getOrCreateLazyType(parentClassName))
       .thenReturn(new LazyType(parentClassName, lazyTypesContext));
 
-    Mockito.when(lazyTypesContext.resolveLazyType(Mockito.argThat(lt -> parentClassName.equals(lt.importPath()))))
+    when(lazyTypesContext.resolveLazyType(argThat(lt -> parentClassName.equals(lt.importPath()))))
       .thenReturn(resolvedParent);
 
     var type = (ClassType) converter.convert("", descriptor, TypeOrigin.LOCAL);
@@ -157,24 +160,24 @@ void classDescriptorConversionTest() {
 
   @Test
   void functionDescriptorConversionTest() {
-    var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
+    var lazyTypesContext = mock(LazyTypesContext.class);
     var converter = new AnyDescriptorToPythonTypeConverter(lazyTypesContext);
-    var descriptor = Mockito.mock(FunctionDescriptor.class);
+    var descriptor = mock(FunctionDescriptor.class);
 
     var returnTypeName = "Returned";
     String returnTypeFqn = "returned.Returned";
     var resolvedReturnType = new ClassTypeBuilder(returnTypeName, returnTypeFqn).build();
 
-    Mockito.when(descriptor.kind()).thenReturn(Descriptor.Kind.FUNCTION);
-    Mockito.when(descriptor.name()).thenReturn("Sample");
-    Mockito.when(descriptor.annotatedReturnTypeName()).thenReturn(returnTypeName);
+    when(descriptor.kind()).thenReturn(Descriptor.Kind.FUNCTION);
+    when(descriptor.name()).thenReturn("Sample");
+    when(descriptor.annotatedReturnTypeName()).thenReturn(returnTypeName);
 
-    TypeAnnotationDescriptor typeAnnotationDescriptor = Mockito.mock(TypeAnnotationDescriptor.class);
-    Mockito.when(typeAnnotationDescriptor.kind()).thenReturn(TypeAnnotationDescriptor.TypeKind.INSTANCE);
-    Mockito.when(typeAnnotationDescriptor.fullyQualifiedName()).thenReturn(returnTypeName);
-    Mockito.when(descriptor.typeAnnotationDescriptor()).thenReturn(typeAnnotationDescriptor);
+    TypeAnnotationDescriptor typeAnnotationDescriptor = mock(TypeAnnotationDescriptor.class);
+    when(typeAnnotationDescriptor.kind()).thenReturn(TypeAnnotationDescriptor.TypeKind.INSTANCE);
+    when(typeAnnotationDescriptor.fullyQualifiedName()).thenReturn(returnTypeName);
+    when(descriptor.typeAnnotationDescriptor()).thenReturn(typeAnnotationDescriptor);
 
-    Mockito.when(descriptor.parameters()).thenReturn(List.of(
+    when(descriptor.parameters()).thenReturn(List.of(
       new FunctionDescriptor.Parameter(
         "p1",
         "Returned",
@@ -187,10 +190,10 @@ void functionDescriptorConversionTest() {
         new LocationInFile("m1", 1, 10,  1, 15))
     ));
 
-    Mockito.when(lazyTypesContext.getOrCreateLazyType(returnTypeName))
+    when(lazyTypesContext.getOrCreateLazyType(returnTypeName))
       .thenReturn(new LazyType(returnTypeName, lazyTypesContext));
 
-    Mockito.when(lazyTypesContext.resolveLazyType(Mockito.argThat(lt -> returnTypeName.equals(lt.importPath()))))
+    when(lazyTypesContext.resolveLazyType(argThat(lt -> returnTypeName.equals(lt.importPath()))))
       .thenReturn(resolvedReturnType);
 
     var type = (FunctionType) converter.convert("", descriptor, TypeOrigin.LOCAL);
@@ -209,22 +212,22 @@ void functionDescriptorConversionTest() {
 
   @Test
   void variableDescriptorConversionTest() {
-    var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
+    var lazyTypesContext = mock(LazyTypesContext.class);
     var converter = new AnyDescriptorToPythonTypeConverter(lazyTypesContext);
-    var descriptor = Mockito.mock(VariableDescriptor.class);
+    var descriptor = mock(VariableDescriptor.class);
 
     var variableTypeName = "Returned";
     String variableTypeFqn = "returned.Returned";
     var resolvedVariableType = new ClassTypeBuilder(variableTypeName, variableTypeFqn).build();
 
-    Mockito.when(descriptor.kind()).thenReturn(Descriptor.Kind.VARIABLE);
-    Mockito.when(descriptor.name()).thenReturn("variable");
-    Mockito.when(descriptor.annotatedType()).thenReturn(variableTypeName);
+    when(descriptor.kind()).thenReturn(Descriptor.Kind.VARIABLE);
+    when(descriptor.name()).thenReturn("variable");
+    when(descriptor.annotatedType()).thenReturn(variableTypeName);
 
-    Mockito.when(lazyTypesContext.getOrCreateLazyTypeWrapper(variableTypeName))
+    when(lazyTypesContext.getOrCreateLazyTypeWrapper(variableTypeName))
       .thenReturn(new LazyTypeWrapper(new LazyType(variableTypeName, lazyTypesContext)));
 
-    Mockito.when(lazyTypesContext.resolveLazyType(Mockito.argThat(lt -> variableTypeName.equals(lt.importPath()))))
+    when(lazyTypesContext.resolveLazyType(argThat(lt -> variableTypeName.equals(lt.importPath()))))
       .thenReturn(resolvedVariableType);
 
     var type = (ObjectType) converter.convert("", descriptor, TypeOrigin.LOCAL);
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/FunctionDescriptorToPythonTypeConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/FunctionDescriptorToPythonTypeConverterTest.java
index 143985ffda..3dca6aa310 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/FunctionDescriptorToPythonTypeConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/FunctionDescriptorToPythonTypeConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,14 +18,15 @@
 
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.python.index.ClassDescriptor;
 
+import static org.mockito.Mockito.mock;
+
 class FunctionDescriptorToPythonTypeConverterTest {
   @Test
   void unsupportedClassTest() {
-    var ctx = Mockito.mock(ConversionContext.class);
-    var descriptor = Mockito.mock(ClassDescriptor.class);
+    var ctx = mock(ConversionContext.class);
+    var descriptor = mock(ClassDescriptor.class);
     var converter = new FunctionDescriptorToPythonTypeConverter();
     Assertions.assertThatThrownBy(() -> converter.convert(ctx, descriptor))
       .isInstanceOf(IllegalArgumentException.class)
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/PythonTypeToDescriptorConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/PythonTypeToDescriptorConverterTest.java
index 60628e34e9..be6f2dbcb7 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/PythonTypeToDescriptorConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/PythonTypeToDescriptorConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/TypeAnnotationToPythonTypeConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/TypeAnnotationToPythonTypeConverterTest.java
index 2552bf7429..c843ebc08d 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/TypeAnnotationToPythonTypeConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/TypeAnnotationToPythonTypeConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,7 +19,6 @@
 import java.util.List;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.types.v2.ObjectType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.python.index.TypeAnnotationDescriptor;
@@ -27,16 +26,18 @@
 import org.sonar.python.types.v2.TypesTestUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class TypeAnnotationToPythonTypeConverterTest {
 
   @Test
   void typeVarWithIncorrectArgsAndIsSelfTrueReturnsUnknown() {
-    var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
-    var ctx = Mockito.mock(ConversionContext.class);
+    var lazyTypesContext = mock(LazyTypesContext.class);
+    var ctx = mock(ConversionContext.class);
     var converter = new TypeAnnotationToPythonTypeConverter();
 
-    Mockito.when(ctx.lazyTypesContext()).thenReturn(lazyTypesContext);
+    when(ctx.lazyTypesContext()).thenReturn(lazyTypesContext);
 
     // Create a TYPE_VAR TypeAnnotationDescriptor with isSelf=true and multiple args
     var innerArg1 = new TypeAnnotationDescriptor("int", TypeAnnotationDescriptor.TypeKind.INSTANCE, List.of(), "int", false);
@@ -74,10 +75,10 @@ void typeVarWithIncorrectArgsAndIsSelfTrueReturnsUnknown() {
    @Test
    void testListInstanceWithAttributes() {
      var lazyTypesContext = new LazyTypesContext(TypesTestUtils.PROJECT_LEVEL_TYPE_TABLE);
-     var ctx = Mockito.mock(ConversionContext.class);
+     var ctx = mock(ConversionContext.class);
      var converter = new TypeAnnotationToPythonTypeConverter();
 
-     Mockito.when(ctx.lazyTypesContext()).thenReturn(lazyTypesContext);
+     when(ctx.lazyTypesContext()).thenReturn(lazyTypesContext);
 
      // Create a INSTANCE TypeAnnotationDescriptor for list[int]
      var intArg = new TypeAnnotationDescriptor("int", TypeAnnotationDescriptor.TypeKind.INSTANCE, List.of(), "int", false);
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/VariableDescriptorToPythonTypeConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/VariableDescriptorToPythonTypeConverterTest.java
index 356b786fff..fd033ba86e 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/VariableDescriptorToPythonTypeConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/VariableDescriptorToPythonTypeConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,7 +19,6 @@
 import java.util.List;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.types.v2.ObjectType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.python.index.ClassDescriptor;
@@ -30,12 +29,13 @@
 import org.sonar.python.types.v2.SpecialFormType;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 class VariableDescriptorToPythonTypeConverterTest {
   @Test
   void unsupportedClassTest() {
-    var ctx = Mockito.mock(ConversionContext.class);
-    var descriptor = Mockito.mock(ClassDescriptor.class);
+    var ctx = mock(ConversionContext.class);
+    var descriptor = mock(ClassDescriptor.class);
     var converter = new VariableDescriptorToPythonTypeConverter();
     Assertions.assertThatThrownBy(() -> converter.convert(ctx, descriptor))
       .isInstanceOf(IllegalArgumentException.class)
@@ -44,7 +44,7 @@ void unsupportedClassTest() {
 
   @Test
   void testSpecialFormTypeConversion() {
-    var ctx = Mockito.mock(ConversionContext.class);
+    var ctx = mock(ConversionContext.class);
     var converter = new VariableDescriptorToPythonTypeConverter();
 
     var typingSelfDescriptor = new VariableDescriptor("Self", "typing.Self", "typing._SpecialForm");
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TrivialTypePropagationVisitorTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TrivialTypePropagationVisitorTest.java
index 13a1338560..382648da3a 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TrivialTypePropagationVisitorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TrivialTypePropagationVisitorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TypeDependenciesCalculatorTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TypeDependenciesCalculatorTest.java
index 4026c6cd15..cc5db369f7 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TypeDependenciesCalculatorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TypeDependenciesCalculatorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TypeInferenceMatchersTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TypeInferenceMatchersTest.java
index 14ee18a597..487ad5fa59 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TypeInferenceMatchersTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/TypeInferenceMatchersTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/typecalculator/CallReturnTypeCalculatorTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/typecalculator/CallReturnTypeCalculatorTest.java
index 7662325513..d8b6215db1 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/typecalculator/CallReturnTypeCalculatorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/typecalculator/CallReturnTypeCalculatorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -19,12 +19,14 @@
 import java.util.List;
 import java.util.Set;
 import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.CallExpression;
 import org.sonar.plugins.python.api.tree.ClassDef;
 import org.sonar.plugins.python.api.tree.FileInput;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.QualifiedExpression;
 import org.sonar.plugins.python.api.types.v2.ClassType;
+import org.sonar.plugins.python.api.types.v2.FunctionType;
 import org.sonar.plugins.python.api.types.v2.ObjectType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.plugins.python.api.types.v2.SelfType;
@@ -91,6 +93,98 @@ void computeCallExpressionType_unknownCallee() {
     assertThat(result).isEqualTo(PythonType.UNKNOWN);
   }
 
+  @Test
+  void computeCallExpressionType_superCall_returnsProxyResolvingMroTail() {
+    FileInput fileInput = parseAndInferTypes("""
+      class O(object):
+        def target(self): pass
+      class X(O): pass
+      class Y(O):
+        def target(self): pass
+      class A(X, Y):
+        def foo(self):
+          super()
+      """);
+
+    CallExpression callExpr = getSuperCall(fileInput);
+
+    PythonType result = CallReturnTypeCalculator.computeCallExpressionType(callExpr, typePredicateContext);
+
+    assertThat(result).isInstanceOf(ObjectType.class);
+    ObjectType objectType = (ObjectType) result;
+    assertThat(objectType.type()).isNotInstanceOf(ClassType.class);
+    assertThat(objectType.type().name()).isEqualTo("super");
+    assertThat(objectType.resolveMember("target"))
+      .hasValueSatisfying(member -> {
+        assertThat(member).isInstanceOf(FunctionType.class);
+        assertThat(((FunctionType) member).fullyQualifiedName()).isEqualTo("my_package.mod.Y.target");
+      });
+    assertThat(objectType.hasMember("target")).isEqualTo(TriBool.TRUE);
+    // ObjectType.hasMember only dispatches to ClassType.instancesHaveMember; SuperProxyType is not
+    // a ClassType so the fallthrough always returns UNKNOWN for unresolved members.
+    assertThat(objectType.hasMember("missing")).isEqualTo(TriBool.UNKNOWN);
+  }
+
+  @Test
+  void computeCallExpressionType_superCallInClassMethod_returnsProxy() {
+    FileInput fileInput = parseAndInferTypes("""
+      class Base:
+        def base_method(self): pass
+      class A(Base):
+        @classmethod
+        def foo(cls):
+          super()
+      """);
+
+    CallExpression callExpr = getSuperCall(fileInput);
+
+    PythonType result = CallReturnTypeCalculator.computeCallExpressionType(callExpr, typePredicateContext);
+
+    assertThat(result).isInstanceOf(ObjectType.class);
+    ObjectType objectType = (ObjectType) result;
+    assertThat(objectType.type()).isNotInstanceOf(ClassType.class);
+    assertThat(objectType.resolveMember("base_method"))
+      .hasValueSatisfying(member -> {
+        assertThat(member).isInstanceOf(FunctionType.class);
+        assertThat(((FunctionType) member).fullyQualifiedName()).isEqualTo("my_package.mod.Base.base_method");
+      });
+  }
+
+  @Test
+  void computeCallExpressionType_superCallOutsideMethod_returnsBuiltinSuperObject() {
+    FileInput fileInput = parseAndInferTypes("""
+      super()
+      """);
+
+    CallExpression callExpr = getSuperCall(fileInput);
+
+    PythonType result = CallReturnTypeCalculator.computeCallExpressionType(callExpr, typePredicateContext);
+
+    assertThat(result).isInstanceOf(ObjectType.class);
+    ObjectType objectType = (ObjectType) result;
+    assertThat(objectType.type()).isInstanceOfSatisfying(ClassType.class, classType -> assertThat(classType.fullyQualifiedName()).isEqualTo("super"));
+  }
+
+  @Test
+  void computeCallExpressionType_superCallInStaticMethod_returnsBuiltinSuperObject() {
+    FileInput fileInput = parseAndInferTypes("""
+      class Base:
+        def base_method(self): pass
+      class A(Base):
+        @staticmethod
+        def foo():
+          super()
+      """);
+
+    CallExpression callExpr = getSuperCall(fileInput);
+
+    PythonType result = CallReturnTypeCalculator.computeCallExpressionType(callExpr, typePredicateContext);
+
+    assertThat(result).isInstanceOf(ObjectType.class);
+    ObjectType objectType = (ObjectType) result;
+    assertThat(objectType.type()).isInstanceOfSatisfying(ClassType.class, classType -> assertThat(classType.fullyQualifiedName()).isEqualTo("super"));
+  }
+
   @Test
   void computeCallExpressionType_selfType_collapsedForInstanceMethodCall() {
     FileInput fileInput = parseAndInferTypes("""
@@ -534,4 +628,10 @@ def reveal_type(x) -> str:
     assertThat(result).isInstanceOf(ObjectType.class);
     assertThat(((ObjectType) result).unwrappedType()).isEqualTo(TypesTestUtils.STR_TYPE);
   }
+
+  private static CallExpression getSuperCall(FileInput fileInput) {
+    return getFirstDescendant(fileInput, tree -> tree instanceof CallExpression callExpression
+      && callExpression.callee() instanceof Name name
+      && "super".equals(name.name()));
+  }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/typecalculator/QualifiedExpressionCalculatorTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/typecalculator/QualifiedExpressionCalculatorTest.java
index 4a6d877cc0..772df71cfa 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/typecalculator/QualifiedExpressionCalculatorTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/types/typecalculator/QualifiedExpressionCalculatorTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -22,6 +22,7 @@
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.types.v2.FunctionType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
+import org.sonar.plugins.python.api.types.v2.UnknownType;
 import org.sonar.python.PythonTestUtils;
 import org.sonar.python.types.v2.matchers.TypePredicateContext;
 
@@ -114,6 +115,37 @@ class A:
     assertThat(result).isEqualTo(PythonType.UNKNOWN);
   }
 
+  @Test
+  void calculate_nonExistentMemberOnClass_returnsUnresolvedImportType() {
+    FileInput fileInput = parseAndInferTypes("""
+      class A:
+        pass
+      A.non_existent
+      """);
+
+    var qualifiedExpression = getQualifiedExpressionFromStatement(fileInput);
+    PythonType result = calculator.calculate(qualifiedExpression);
+
+    assertThat(result).isInstanceOf(UnknownType.UnresolvedImportType.class);
+    var unresolvedType = (UnknownType.UnresolvedImportType) result;
+    assertThat(unresolvedType.importPath()).isEqualTo("my_package.mod.A.non_existent");
+  }
+
+  @Test
+  void calculate_unknownMemberOnKnownModule_returnsUnresolvedImportType() {
+    FileInput fileInput = parseAndInferTypes("""
+      import os
+      os.nonexistent_member
+      """);
+
+    var qualifiedExpression = getQualifiedExpressionFromStatement(fileInput);
+    PythonType result = calculator.calculate(qualifiedExpression);
+
+    assertThat(result).isInstanceOf(UnknownType.UnresolvedImportType.class);
+    var unresolvedType = (UnknownType.UnresolvedImportType) result;
+    assertThat(unresolvedType.importPath()).isEqualTo("os.nonexistent_member");
+  }
+
   private static QualifiedExpression getQualifiedExpressionFromStatement(FileInput fileInput) {
     return PythonTestUtils.getLastDescendant(fileInput, t -> t.is(Tree.Kind.QUALIFIED_EXPR));
   }
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ClassSymbolToDescriptorConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ClassSymbolToDescriptorConverterTest.java
index 628a6a4527..b67b0a82e5 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ClassSymbolToDescriptorConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ClassSymbolToDescriptorConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/FunctionSymbolToDescriptorConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/FunctionSymbolToDescriptorConverterTest.java
index 94b5e5c353..af27d53cc0 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/FunctionSymbolToDescriptorConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/FunctionSymbolToDescriptorConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ModuleSymbolToDescriptorConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ModuleSymbolToDescriptorConverterTest.java
index 25e0c5cbc0..f2cac2d4a2 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ModuleSymbolToDescriptorConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ModuleSymbolToDescriptorConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/OverloadedFunctionSymbolToDescriptorConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/OverloadedFunctionSymbolToDescriptorConverterTest.java
index e4c45f282e..843f019636 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/OverloadedFunctionSymbolToDescriptorConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/OverloadedFunctionSymbolToDescriptorConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ParameterSymbolToDescriptorConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ParameterSymbolToDescriptorConverterTest.java
index 8ff2b051da..b8ed64fddd 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ParameterSymbolToDescriptorConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/ParameterSymbolToDescriptorConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/TypeShedDescriptorsProviderTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/TypeShedDescriptorsProviderTest.java
index 84a5fcc65b..24ef1ee4b9 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/TypeShedDescriptorsProviderTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/TypeShedDescriptorsProviderTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/TypeShedUtilsTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/TypeShedUtilsTest.java
index 979d238740..e0acb563d2 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/TypeShedUtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/TypeShedUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/VarSymbolToDescriptorConverterTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/VarSymbolToDescriptorConverterTest.java
index 67611fd5af..8ad6515bd1 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/VarSymbolToDescriptorConverterTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typeshed/VarSymbolToDescriptorConverterTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/BasicTypeTableTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/BasicTypeTableTest.java
index f88ecd6106..2e05e45a34 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/BasicTypeTableTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/BasicTypeTableTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/CachedTypeTableTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/CachedTypeTableTest.java
index de5251263e..64c9777980 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/CachedTypeTableTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/CachedTypeTableTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/ProjectLevelTypeTableTest.java b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/ProjectLevelTypeTableTest.java
index 8d4422336f..98372936c0 100644
--- a/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/ProjectLevelTypeTableTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/semantic/v2/typetable/ProjectLevelTypeTableTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tests/UnittestUtilsTest.java b/python-frontend/src/test/java/org/sonar/python/tests/UnittestUtilsTest.java
deleted file mode 100644
index e43fa49304..0000000000
--- a/python-frontend/src/test/java/org/sonar/python/tests/UnittestUtilsTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the Sonar Source-Available License for more details.
- *
- * You should have received a copy of the Sonar Source-Available License
- * along with this program; if not, see https://sonarsource.com/license/ssal/
- */
-package org.sonar.python.tests;
-
-
-import org.junit.jupiter.api.Test;
-import org.sonar.plugins.python.api.tree.FileInput;
-import org.sonar.plugins.python.api.tree.Tree;
-import org.sonar.python.PythonTestUtils;
-import org.sonar.python.semantic.SymbolTableBuilder;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.python.PythonTestUtils.pythonFile;
-
-class UnittestUtilsTest  {
-
-  @Test
-  void test_isWithinUnittestTestCase() {
-    String code = "import unittest\nclass A(unittest.TestCase):  ...";
-    FileInput fileInput = PythonTestUtils.parse(new SymbolTableBuilder("", pythonFile("mod1.py")), code);
-    Tree tree = PythonTestUtils.getLastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
-    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isTrue();
-
-    code = "import unittest\nclass A(unittest.case.TestCase):  ...";
-    fileInput = PythonTestUtils.parse(new SymbolTableBuilder("", pythonFile("mod1.py")), code);
-    tree = PythonTestUtils.getLastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
-    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isTrue();
-
-    code = "import random_wrapper\nclass A(random_wrapper.unittest.TestCase):  ...";
-    fileInput = PythonTestUtils.parse(new SymbolTableBuilder("", pythonFile("mod1.py")), code);
-    tree = PythonTestUtils.getLastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
-    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isTrue();
-
-    code = "import random\nclass A(random.TestCase):  ...";
-    fileInput = PythonTestUtils.parse(new SymbolTableBuilder("", pythonFile("mod1.py")), code);
-    tree = PythonTestUtils.getLastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
-    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isFalse();
-
-    code = "import unittest\nclass A(unittest.other):  ...";
-    fileInput = PythonTestUtils.parse(new SymbolTableBuilder("", pythonFile("mod1.py")), code);
-    tree = PythonTestUtils.getLastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
-    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isFalse();
-
-    code = "...";
-    fileInput = PythonTestUtils.parse(new SymbolTableBuilder("", pythonFile("mod1.py")), code);
-    tree = PythonTestUtils.getLastDescendant(fileInput, t -> t.is(Tree.Kind.ELLIPSIS));
-    assertThat(UnittestUtils.isWithinUnittestTestCase(tree)).isFalse();
-  }
-
-  @Test
-  void all_methods() {
-    assertThat(UnittestUtils.allMethods()).hasSize(61);
-  }
-
-  @Test
-  void all_assert_methods() {
-    assertThat(UnittestUtils.allAssertMethods()).hasSize(38);
-  }
-}
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/BinaryExpressionImplTest.java b/python-frontend/src/test/java/org/sonar/python/tree/BinaryExpressionImplTest.java
index 6ecbc083cf..7c4141bcd2 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/BinaryExpressionImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/BinaryExpressionImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/CallExpressionImplTest.java b/python-frontend/src/test/java/org/sonar/python/tree/CallExpressionImplTest.java
index acbd85de3d..5407aee342 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/CallExpressionImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/CallExpressionImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/ComprehensionExpressionImplTest.java b/python-frontend/src/test/java/org/sonar/python/tree/ComprehensionExpressionImplTest.java
index 130a321ea0..31076b263c 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/ComprehensionExpressionImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/ComprehensionExpressionImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/IPythonTreeMakerTest.java b/python-frontend/src/test/java/org/sonar/python/tree/IPythonTreeMakerTest.java
index 90c59b6e72..75582d5d20 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/IPythonTreeMakerTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/IPythonTreeMakerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/NameImplTest.java b/python-frontend/src/test/java/org/sonar/python/tree/NameImplTest.java
index 738ef30a52..7b103313c8 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/NameImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/NameImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/ParenthesizedExpressionImplTest.java b/python-frontend/src/test/java/org/sonar/python/tree/ParenthesizedExpressionImplTest.java
index 788aa8e725..cdef033f8c 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/ParenthesizedExpressionImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/ParenthesizedExpressionImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerMatchStatementTest.java b/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerMatchStatementTest.java
index 9e3f9ffe5a..82f1d1c90d 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerMatchStatementTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerMatchStatementTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -49,7 +49,7 @@
 import org.sonar.python.parser.RuleTest;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class PythonTreeMakerMatchStatementTest extends RuleTest {
 
@@ -331,12 +331,8 @@ void class_pattern() {
 
   @Test
   void class_pattern_positional_after_keyword() {
-    try {
-      pattern("case A(foo=42, x, y): ...");
-      fail("Position patterns cannot follow keyword patterns");
-    } catch (RecognitionException exception) {
-      assertThat(exception.getMessage()).isEqualTo("Parse error at line 1: Positional patterns follow keyword patterns.");
-    }
+    RecognitionException exception = assertThrows(RecognitionException.class, () -> pattern("case A(foo=42, x, y): ..."));
+    assertThat(exception.getMessage()).isEqualTo("Parse error at line 1: Positional patterns follow keyword patterns.");
   }
 
   private void assertSequenceElements(SequencePattern sequencePattern, String... elements) {
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerTest.java b/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerTest.java
index 63e4cbc75f..bfc67d9b64 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -119,7 +119,6 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.assertj.core.api.Assertions.fail;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
 
@@ -164,12 +163,8 @@ void variadic_is_kind() {
 
   @Test
   void unexpected_expression_should_throw_an_exception() {
-    try {
-      parse("", treeMaker::expression);
-      fail("unexpected ASTNode type for expression should not succeed to be translated to Strongly typed AST");
-    } catch (IllegalStateException iae) {
-      assertThat(iae).hasMessage("Expression FILE_INPUT not correctly translated to strongly typed AST");
-    }
+    IllegalStateException iae = assertThrows(IllegalStateException.class, () -> parse("", treeMaker::expression));
+    assertThat(iae).hasMessage("Expression FILE_INPUT not correctly translated to strongly typed AST");
   }
 
   @Test
@@ -1391,13 +1386,9 @@ void assignement_expression() {
 
 
     setRootRule(PythonGrammar.NAMED_EXPR_TEST);
-    try {
-      astNode = p.parse("a.b := 12");
-      treeMaker.expression(astNode);
-      fail("Expected RecognitionException");
-    } catch (RecognitionException e) {
-      assertThat(e.getLine()).isOne();
-    }
+    AstNode invalidWalrusNode = p.parse("a.b := 12");
+    RecognitionException walrusException = assertThrows(RecognitionException.class, () -> treeMaker.expression(invalidWalrusNode));
+    assertThat(walrusException.getLine()).isOne();
   }
 
   @Test
@@ -2070,6 +2061,18 @@ void numeric_literal_expression() {
     testNumericLiteral("0777", 511L);
     testNumericLiteral("0x28", 0x28L);
     testNumericLiteral("0X28", 0x28L);
+    testNumericLiteral("0.0", 0L);
+    testNumericLiteral("42.0", 42L);
+    testNumericLiteral("1e3", 1000L);
+    testNumericLiteral("3_0.0", 30L);
+  }
+
+  @Test
+  void numeric_literal_float_non_integral_valueAsLong_throws() {
+    setRootRule(PythonGrammar.ATOM);
+    Expression expression = parse("0.5", treeMaker::expression);
+    assertThat(expression.is(Tree.Kind.NUMERIC_LITERAL)).isTrue();
+    assertThatThrownBy(((NumericLiteral) expression)::valueAsLong).isInstanceOf(NumberFormatException.class);
   }
 
   private void testNumericLiteral(String code, Long expectedValue) {
@@ -2471,12 +2474,8 @@ void generator_expression() {
     firstArg = ((RegularArgument) call.arguments().get(0)).expression();
     assertThat(firstArg.getKind()).isEqualTo(Tree.Kind.GENERATOR_EXPR);
 
-    try {
-      parse("foo(1, x*x for x in range(10))", treeMaker::expression);
-      fail("generator expression must be parenthesized unless it's the unique argument in arglist");
-    } catch (RecognitionException re) {
-      assertThat(re).hasMessage("Parse error at line 1: Generator expression must be parenthesized if not sole argument.");
-    }
+    RecognitionException re = assertThrows(RecognitionException.class, () -> parse("foo(1, x*x for x in range(10))", treeMaker::expression));
+    assertThat(re).hasMessage("Parse error at line 1: Generator expression must be parenthesized if not sole argument.");
   }
 
   @Test
@@ -2694,18 +2693,12 @@ void repr_expression() {
   @Test
   @Timeout(2)
   public void should_not_require_exponential_time() {
-    try {
-      p.parse("((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((");
-      fail("Expected RecognitionException");
-    } catch (RecognitionException e) {
-      assertThat(e.getLine()).isOne();
-    }
-    try {
-      p.parse("````````````````````````````````````````````````````````````````````````````````");
-      fail("Expected RecognitionException");
-    } catch (RecognitionException e) {
-      assertThat(e.getLine()).isOne();
-    }
+    RecognitionException openParensException = assertThrows(RecognitionException.class,
+      () -> p.parse("(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((("));
+    assertThat(openParensException.getLine()).isOne();
+    RecognitionException backticksException = assertThrows(RecognitionException.class,
+      () -> p.parse("````````````````````````````````````````````````````````````````````````````````"));
+    assertThat(backticksException.getLine()).isOne();
   }
 
   @Test
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerUtilsTest.java b/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerUtilsTest.java
index fe0678fd8a..056085b688 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerUtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/SliceExpressionImplTest.java b/python-frontend/src/test/java/org/sonar/python/tree/SliceExpressionImplTest.java
index ae21480ddd..231dd7c2b1 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/SliceExpressionImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/SliceExpressionImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/StringElementImplTest.java b/python-frontend/src/test/java/org/sonar/python/tree/StringElementImplTest.java
index ff48794bab..6c3140ee34 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/StringElementImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/StringElementImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/StringLiteralImplTest.java b/python-frontend/src/test/java/org/sonar/python/tree/StringLiteralImplTest.java
index e6bec8b589..61c1c495ea 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/StringLiteralImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/StringLiteralImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/TokenEnricherTest.java b/python-frontend/src/test/java/org/sonar/python/tree/TokenEnricherTest.java
index 91d5c053de..c50e3c1a3f 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/TokenEnricherTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/TokenEnricherTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/TreeUtilsTest.java b/python-frontend/src/test/java/org/sonar/python/tree/TreeUtilsTest.java
index b68c40b0f9..6f65e538be 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/TreeUtilsTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/TreeUtilsTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -40,9 +40,11 @@
 import org.sonar.plugins.python.api.tree.IfStatement;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.NumericLiteral;
+import org.sonar.plugins.python.api.tree.Parameter;
 import org.sonar.plugins.python.api.tree.PassStatement;
 import org.sonar.plugins.python.api.tree.QualifiedExpression;
 import org.sonar.plugins.python.api.tree.RegularArgument;
+import org.sonar.plugins.python.api.tree.UnpackingExpression;
 import org.sonar.plugins.python.api.tree.Statement;
 import org.sonar.plugins.python.api.tree.Token;
 import org.sonar.plugins.python.api.tree.Tree;
@@ -923,6 +925,43 @@ def inner(): pass
     assertThat(TreeUtils.getEnclosingClassDef(funcDefInner)).isNull();
   }
 
+  @Test
+  void test_isDoubleStarExpression() {
+    FileInput fileInput = PythonTestUtils.parse("""
+      def foo(*args, **kwargs): pass
+      bar(**x, *y)
+      """);
+
+    FunctionDef funcDef = PythonTestUtils.getFirstChild(fileInput, t -> t.is(Kind.FUNCDEF));
+    Parameter doubleStarParam = TreeUtils.nonTupleParameters(funcDef).stream()
+      .filter(p -> p.name() != null && "kwargs".equals(p.name().name()))
+      .findFirst().get();
+    Parameter singleStarParam = TreeUtils.nonTupleParameters(funcDef).stream()
+      .filter(p -> p.name() != null && "args".equals(p.name().name()))
+      .findFirst().get();
+
+    assertThat(TreeUtils.isDoubleStarExpression(doubleStarParam)).isTrue();
+    assertThat(TreeUtils.isDoubleStarExpression(singleStarParam)).isFalse();
+
+    CallExpression callExpr = PythonTestUtils.getFirstChild(fileInput, t -> t.is(Kind.CALL_EXPR));
+    UnpackingExpression doubleStarUnpacking = callExpr.arguments().stream()
+      .filter(UnpackingExpression.class::isInstance)
+      .map(UnpackingExpression.class::cast)
+      .filter(u -> u.expression() instanceof Name name && "x".equals(name.name()))
+      .findFirst().get();
+    UnpackingExpression singleStarUnpacking = callExpr.arguments().stream()
+      .filter(UnpackingExpression.class::isInstance)
+      .map(UnpackingExpression.class::cast)
+      .filter(u -> u.expression() instanceof Name name && "y".equals(name.name()))
+      .findFirst().get();
+
+    assertThat(TreeUtils.isDoubleStarExpression(doubleStarUnpacking)).isTrue();
+    assertThat(TreeUtils.isDoubleStarExpression(singleStarUnpacking)).isFalse();
+
+    // A tree that is neither Parameter nor UnpackingExpression
+    assertThat(TreeUtils.isDoubleStarExpression(funcDef)).isFalse();
+  }
+
   @Test
   void testIsConstantName() {
     assertThat(TreeUtils.isConstantName("_FOO")).isTrue();
diff --git a/python-frontend/src/test/java/org/sonar/python/tree/UnaryExpressionImplTest.java b/python-frontend/src/test/java/org/sonar/python/tree/UnaryExpressionImplTest.java
index 71381e9838..3393645a5a 100644
--- a/python-frontend/src/test/java/org/sonar/python/tree/UnaryExpressionImplTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/tree/UnaryExpressionImplTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/AnyTypeTest.java b/python-frontend/src/test/java/org/sonar/python/types/AnyTypeTest.java
index c5de1f50f0..fd30308713 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/AnyTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/AnyTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/DeclaredTypeTest.java b/python-frontend/src/test/java/org/sonar/python/types/DeclaredTypeTest.java
index 0b2768a374..7d947fc454 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/DeclaredTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/DeclaredTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/InferredTypesTest.java b/python-frontend/src/test/java/org/sonar/python/types/InferredTypesTest.java
index 1bd04c111a..104d89c76f 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/InferredTypesTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/InferredTypesTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/MemberResolutionTest.java b/python-frontend/src/test/java/org/sonar/python/types/MemberResolutionTest.java
index 36d2f30be3..5a40e45d70 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/MemberResolutionTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/MemberResolutionTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/RuntimeTypeTest.java b/python-frontend/src/test/java/org/sonar/python/types/RuntimeTypeTest.java
index ac8a0c1194..9361310469 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/RuntimeTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/RuntimeTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/TypeInferenceProgramStateTest.java b/python-frontend/src/test/java/org/sonar/python/types/TypeInferenceProgramStateTest.java
index c2c377a2b0..5f8a8b922d 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/TypeInferenceProgramStateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/TypeInferenceProgramStateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/TypeInferenceTest.java b/python-frontend/src/test/java/org/sonar/python/types/TypeInferenceTest.java
index 8770a7535f..cada42c44d 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/TypeInferenceTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/TypeInferenceTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/TypeShedTest.java b/python-frontend/src/test/java/org/sonar/python/types/TypeShedTest.java
index 0453c37e89..8bf30b85ce 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/TypeShedTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/TypeShedTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -27,7 +27,6 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
-import org.mockito.Mockito;
 import org.slf4j.event.Level;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.plugins.python.api.ProjectPythonVersion;
@@ -48,6 +47,8 @@
 import static org.assertj.core.api.Assertions.tuple;
 import static org.sonar.python.types.TypeShed.symbolWithFQN;
 import static org.sonar.python.types.TypeShed.symbolsForModule;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class TypeShedTest {
 
@@ -56,6 +57,7 @@ class TypeShedTest {
 
   @BeforeEach
   void setPythonVersions() {
+    TypeShed.setProjectLevelSymbolTable(ProjectLevelSymbolTable.empty());
     ProjectPythonVersion.setCurrentVersions(PythonVersionUtils.allVersions());
     TypeShed.resetBuiltinSymbols();
   }
@@ -148,10 +150,11 @@ void stdlib_symbols() {
 
   @Test
   void symbols_not_retrieved_when_within_same_project() {
-    ProjectLevelSymbolTable projectLevelSymbolTable = Mockito.mock(ProjectLevelSymbolTable.class);
-    TypeShed.setProjectLevelSymbolTable(projectLevelSymbolTable);
+    ProjectLevelSymbolTable firstProjectLevelSymbolTable = mock(ProjectLevelSymbolTable.class);
+    TypeShed.setProjectLevelSymbolTable(firstProjectLevelSymbolTable);
+    when(firstProjectLevelSymbolTable.projectBasePackages()).thenReturn(Set.of("sklearn"));
+    TypeShed.resetBuiltinSymbols();
 
-    Mockito.when(projectLevelSymbolTable.projectBasePackages()).thenReturn(Set.of("sklearn"));
     Map sklearnSymbols = symbolsForModule("sklearn.ensemble");
     assertThat(sklearnSymbols).isEmpty();
     sklearnSymbols = symbolsForModule("sklearn");
@@ -159,7 +162,11 @@ void symbols_not_retrieved_when_within_same_project() {
     Symbol symbol = symbolWithFQN("sklearn.ensemble", "sklearn.ensemble.RandomForestClassifier");
     assertThat(symbol).isNull();
 
-    Mockito.when(projectLevelSymbolTable.projectBasePackages()).thenReturn(Set.of("unrelated"));
+    ProjectLevelSymbolTable secondProjectLevelSymbolTable = mock(ProjectLevelSymbolTable.class);
+    TypeShed.setProjectLevelSymbolTable(secondProjectLevelSymbolTable);
+    when(secondProjectLevelSymbolTable.projectBasePackages()).thenReturn(Set.of("unrelated"));
+    TypeShed.resetBuiltinSymbols();
+
     sklearnSymbols = symbolsForModule("sklearn.ensemble");
     assertThat(sklearnSymbols).isNotEmpty();
     symbol = symbolWithFQN("sklearn.ensemble", "sklearn.ensemble.RandomForestClassifier");
@@ -284,6 +291,16 @@ void package_django() {
     assertThat(responseSymbol.fullyQualifiedName()).isEqualTo("django.http.response.HttpResponse");
   }
 
+  @Test
+  void package_django_contrib_auth() {
+    Map djangoAuthSymbols = symbolsForModule("django.contrib.auth.models");
+    assertThat(djangoAuthSymbols).isNotEmpty();
+    Symbol userSymbol = djangoAuthSymbols.get("User");
+    assertThat(userSymbol).isNotNull();
+    assertThat(userSymbol.kind()).isEqualTo(Kind.CLASS);
+    assertThat(userSymbol.fullyQualifiedName()).isEqualTo("django.contrib.auth.models.User");
+  }
+
   @Test
   void return_type_hints() {
     Map symbols = symbolsForModule("typing");
@@ -605,4 +622,16 @@ void customDbStubs() {
     var pymysql = symbolsForModule("pymysql");
     assertThat(pymysql.get("connect")).isInstanceOf(FunctionSymbol.class);
   }
+
+  @Test
+  void resets_typeshed_after_python_version_change() {
+    setPythonVersions(Set.of(PythonVersionUtils.Version.V_310));
+
+    assertThat(TypeShed.typeShedClass("object").canHaveMember("__getstate__")).isFalse();
+
+    setPythonVersions(PythonVersionUtils.allVersions());
+
+    assertThat(TypeShed.typeShedClass("object").canHaveMember("__getstate__")).isTrue();
+  }
+
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/types/UnionTypeTest.java b/python-frontend/src/test/java/org/sonar/python/types/UnionTypeTest.java
index bbd450917a..c97a4f215a 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/UnionTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/UnionTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/UnknownClassTypeTest.java b/python-frontend/src/test/java/org/sonar/python/types/UnknownClassTypeTest.java
index 3b7ca09646..984da39829 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/UnknownClassTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/UnknownClassTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/LazyTypeTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/LazyTypeTest.java
index 2501ee2696..f5d6277cfb 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/LazyTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/LazyTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.types.v2;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.types.v2.FunctionType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.python.semantic.ProjectLevelSymbolTable;
@@ -26,6 +25,8 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 import static org.sonar.python.types.v2.TypesTestUtils.BOOL_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.INT_TYPE;
@@ -34,8 +35,8 @@ class LazyTypeTest {
 
   @Test
   void lazyTypeThrowExceptionsWhenInteractedWith() {
-    LazyTypesContext lazyTypesContext = Mockito.mock(LazyTypesContext.class);
-    when(lazyTypesContext.resolveLazyType(Mockito.any())).thenReturn(INT_TYPE);
+    LazyTypesContext lazyTypesContext = mock(LazyTypesContext.class);
+    when(lazyTypesContext.resolveLazyType(any())).thenReturn(INT_TYPE);
     LazyType lazyType = new LazyType("random", lazyTypesContext);
     assertThat(lazyType.resolve()).isEqualTo(INT_TYPE);
     assertThatThrownBy(lazyType::unwrappedType).isInstanceOf(IllegalStateException.class).hasMessage("Lazy types should not be interacted with.");
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/LazyTypeWrapperTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/LazyTypeWrapperTest.java
index f712d729fe..e56fcdf7d9 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/LazyTypeWrapperTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/LazyTypeWrapperTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,10 +17,11 @@
 package org.sonar.python.types.v2;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.python.semantic.v2.LazyTypesContext;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 import static org.sonar.python.types.v2.TypesTestUtils.INT_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.STR_TYPE;
@@ -32,8 +33,8 @@ class LazyTypeWrapperTest {
 
   @Test
   void lazyTypeIsResolvedWhenAccessed() {
-    LazyTypesContext lazyTypesContext = Mockito.mock(LazyTypesContext.class);
-    when(lazyTypesContext.resolveLazyType(Mockito.any())).thenReturn(INT_TYPE);
+    LazyTypesContext lazyTypesContext = mock(LazyTypesContext.class);
+    when(lazyTypesContext.resolveLazyType(any())).thenReturn(INT_TYPE);
     LazyType lazyType = new LazyType("random", lazyTypesContext);
     LazyTypeWrapper lazyTypeWrapper = new LazyTypeWrapper(lazyType);
     assertThat(lazyTypeWrapper.isResolved()).isFalse();
@@ -51,7 +52,7 @@ void resolvingNonLazyTypeThrowsException() {
 
   @Test
   void testEquals() {
-    var lazyTypeWrapper = new LazyTypeWrapper(new LazyType("random", Mockito.mock(LazyTypesContext.class)));
+    var lazyTypeWrapper = new LazyTypeWrapper(new LazyType("random", mock(LazyTypesContext.class)));
     assertThat(lazyTypeWrapper.equals(lazyTypeWrapper)).isTrue();
     assertThat(lazyTypeWrapper.equals(null)).isFalse();
     assertThat(lazyTypeWrapper.equals("str")).isFalse();
@@ -59,7 +60,7 @@ void testEquals() {
 
   @Test
   void testToString() {
-    var lazyTypeWrapper = new LazyTypeWrapper(new LazyType("random", Mockito.mock(LazyTypesContext.class)));
+    var lazyTypeWrapper = new LazyTypeWrapper(new LazyType("random", mock(LazyTypesContext.class)));
     assertThat(lazyTypeWrapper.toString()).startsWith("LazyTypeWrapper{type=");
   }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/LazyUnionTypeTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/LazyUnionTypeTest.java
index 7ae70e4e43..5444c9900c 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/LazyUnionTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/LazyUnionTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,7 +18,6 @@
 
 import java.util.Set;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.plugins.python.api.types.v2.UnionType;
 import org.sonar.plugins.python.api.types.v2.UnknownType;
@@ -27,6 +26,9 @@
 import org.sonar.python.semantic.v2.typetable.ProjectLevelTypeTable;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
 import static org.sonar.python.types.v2.TypesTestUtils.FLOAT_TYPE;
 import static org.sonar.python.types.v2.TypesTestUtils.INT_TYPE;
@@ -35,8 +37,8 @@ class LazyUnionTypeTest {
 
   @Test
   void lazyUnionTypeResolvesNestedLazyTypesWhenAccessed() {
-    LazyTypesContext lazyTypesContext = Mockito.mock(LazyTypesContext.class);
-    when(lazyTypesContext.resolveLazyType(Mockito.any())).thenReturn(INT_TYPE);
+    LazyTypesContext lazyTypesContext = mock(LazyTypesContext.class);
+    when(lazyTypesContext.resolveLazyType(any())).thenReturn(INT_TYPE);
     LazyType lazyType = new LazyType("random", lazyTypesContext);
     LazyUnionType lazyUnionType = (LazyUnionType) LazyUnionType.or(Set.of(lazyType, FLOAT_TYPE));
     UnionType unionType = (UnionType) lazyUnionType.resolve();
@@ -45,7 +47,7 @@ void lazyUnionTypeResolvesNestedLazyTypesWhenAccessed() {
 
   @Test
   void flattened() {
-    LazyTypesContext lazyTypesContext = Mockito.spy(new LazyTypesContext(new ProjectLevelTypeTable(ProjectLevelSymbolTable.empty())));
+    LazyTypesContext lazyTypesContext = spy(new LazyTypesContext(new ProjectLevelTypeTable(ProjectLevelSymbolTable.empty())));
 
     var lazyType1 = lazyTypeUnresolved("lazy1", lazyTypesContext);
     var lazyType2 = lazyTypeUnresolved("lazy2", lazyTypesContext);
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/SpecialFormTypeTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/SpecialFormTypeTest.java
index c66b586f53..bd706d1926 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/SpecialFormTypeTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/SpecialFormTypeTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/TypeCheckMapTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/TypeCheckMapTest.java
index c3d615042e..a72e147c27 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/TypeCheckMapTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/TypeCheckMapTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/TypeCheckerTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/TypeCheckerTest.java
index 0f71be9ca3..32bd259c83 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/TypeCheckerTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/TypeCheckerTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/TypeInferenceProgramStateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/TypeInferenceProgramStateTest.java
index ab6e41ef99..457c0ae611 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/TypeInferenceProgramStateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/TypeInferenceProgramStateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/TypesTestUtils.java b/python-frontend/src/test/java/org/sonar/python/types/v2/TypesTestUtils.java
index 205ca498d9..468833e2e1 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/TypesTestUtils.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/TypesTestUtils.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -41,6 +41,7 @@ public class TypesTestUtils {
   public static final PythonType COMPLEX_TYPE = BUILTINS.resolveMember("complex").get();
   public static final PythonType BOOL_TYPE = BUILTINS.resolveMember("bool").get();
   public static final PythonType STR_TYPE = BUILTINS.resolveMember("str").get();
+  public static final PythonType BYTES_TYPE = BUILTINS.resolveMember("bytes").get();
   public static final PythonType LIST_TYPE = BUILTINS.resolveMember("list").get();
   public static final PythonType TUPLE_TYPE = BUILTINS.resolveMember("tuple").get();
   public static final PythonType SET_TYPE = BUILTINS.resolveMember("set").get();
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/AllTypePredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/AllTypePredicateTest.java
index b74ed7983a..78ebc93385 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/AllTypePredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/AllTypePredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.types.v2.matchers;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.types.v2.FunctionType;
@@ -26,51 +25,54 @@
 import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class AllTypePredicateTest {
 
   @Test
   void testPredicate() {
-    FunctionType function1 = Mockito.mock(FunctionType.class);
-    Expression expression1 = Mockito.mock();
-    Mockito.when(expression1.typeV2()).thenReturn(function1);
+    FunctionType function1 = mock(FunctionType.class);
+    Expression expression1 = mock();
+    when(expression1.typeV2()).thenReturn(function1);
 
 
-    TypePredicate truePredicate = Mockito.mock(TypePredicate.class);
-    Mockito.when(truePredicate.check(Mockito.any(), Mockito.any())).thenReturn(TriBool.TRUE);
+    TypePredicate truePredicate = mock(TypePredicate.class);
+    when(truePredicate.check(any(), any())).thenReturn(TriBool.TRUE);
 
-    TypePredicate falsePredicate = Mockito.mock(TypePredicate.class);
-    Mockito.when(falsePredicate.check(Mockito.any(), Mockito.any())).thenReturn(TriBool.FALSE);
+    TypePredicate falsePredicate = mock(TypePredicate.class);
+    when(falsePredicate.check(any(), any())).thenReturn(TriBool.FALSE);
 
-    TypePredicate unknownPredicate = Mockito.mock(TypePredicate.class);
-    Mockito.when(unknownPredicate.check(Mockito.any(), Mockito.any())).thenReturn(TriBool.UNKNOWN);
+    TypePredicate unknownPredicate = mock(TypePredicate.class);
+    when(unknownPredicate.check(any(), any())).thenReturn(TriBool.UNKNOWN);
 
     TypeMatcher trueMatcher = MatchersTestUtils.createTypeMatcher(truePredicate);
     TypeMatcher falseMatcher = MatchersTestUtils.createTypeMatcher(falsePredicate);
     TypeMatcher unknownMatcher = MatchersTestUtils.createTypeMatcher(unknownPredicate);
 
     TypeMatcher singleTrue = TypeMatchers.all(trueMatcher);
-    assertThat(singleTrue.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.TRUE);
+    assertThat(singleTrue.evaluateFor(expression1, mock())).isEqualTo(TriBool.TRUE);
 
     TypeMatcher bothTrue = TypeMatchers.all(trueMatcher, trueMatcher);
-    assertThat(bothTrue.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.TRUE);
+    assertThat(bothTrue.evaluateFor(expression1, mock())).isEqualTo(TriBool.TRUE);
 
     TypeMatcher trueFalse = TypeMatchers.all(trueMatcher, falseMatcher);
-    assertThat(trueFalse.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.FALSE);
+    assertThat(trueFalse.evaluateFor(expression1, mock())).isEqualTo(TriBool.FALSE);
 
     TypeMatcher trueUnknown = TypeMatchers.all(trueMatcher, unknownMatcher);
-    assertThat(trueUnknown.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.UNKNOWN);
+    assertThat(trueUnknown.evaluateFor(expression1, mock())).isEqualTo(TriBool.UNKNOWN);
 
     TypeMatcher bothUnknown = TypeMatchers.all(unknownMatcher, unknownMatcher);
-    assertThat(bothUnknown.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.UNKNOWN);
+    assertThat(bothUnknown.evaluateFor(expression1, mock())).isEqualTo(TriBool.UNKNOWN);
 
     TypeMatcher falseTrue = TypeMatchers.all(falseMatcher, trueMatcher);
-    assertThat(falseTrue.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.FALSE);
+    assertThat(falseTrue.evaluateFor(expression1, mock())).isEqualTo(TriBool.FALSE);
 
     TypeMatcher falseUnknown = TypeMatchers.all(falseMatcher, unknownMatcher);
-    assertThat(falseUnknown.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.FALSE);
+    assertThat(falseUnknown.evaluateFor(expression1, mock())).isEqualTo(TriBool.FALSE);
 
     TypeMatcher unknownFalse = TypeMatchers.all(falseMatcher, unknownMatcher);
-    assertThat(unknownFalse.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.FALSE);
+    assertThat(unknownFalse.evaluateFor(expression1, mock())).isEqualTo(TriBool.FALSE);
   }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/AnyTypePredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/AnyTypePredicateTest.java
index 4d42a4b765..2e5192826c 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/AnyTypePredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/AnyTypePredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.types.v2.matchers;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.types.v2.FunctionType;
@@ -26,54 +25,57 @@
 import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class AnyTypePredicateTest {
 
   @Test
   void testPredicate() {
-    FunctionType function1 = Mockito.mock(FunctionType.class);
-    Expression expression1 = Mockito.mock();
-    Mockito.when(expression1.typeV2()).thenReturn(function1);
+    FunctionType function1 = mock(FunctionType.class);
+    Expression expression1 = mock();
+    when(expression1.typeV2()).thenReturn(function1);
 
 
-    TypePredicate truePredicate = Mockito.mock(TypePredicate.class);
-    Mockito.when(truePredicate.check(Mockito.any(), Mockito.any())).thenReturn(TriBool.TRUE);
+    TypePredicate truePredicate = mock(TypePredicate.class);
+    when(truePredicate.check(any(), any())).thenReturn(TriBool.TRUE);
 
-    TypePredicate falsePredicate = Mockito.mock(TypePredicate.class);
-    Mockito.when(falsePredicate.check(Mockito.any(), Mockito.any())).thenReturn(TriBool.FALSE);
+    TypePredicate falsePredicate = mock(TypePredicate.class);
+    when(falsePredicate.check(any(), any())).thenReturn(TriBool.FALSE);
 
-    TypePredicate unknownPredicate = Mockito.mock(TypePredicate.class);
-    Mockito.when(unknownPredicate.check(Mockito.any(), Mockito.any())).thenReturn(TriBool.UNKNOWN);
+    TypePredicate unknownPredicate = mock(TypePredicate.class);
+    when(unknownPredicate.check(any(), any())).thenReturn(TriBool.UNKNOWN);
 
     TypeMatcher trueMatcher = MatchersTestUtils.createTypeMatcher(truePredicate);
     TypeMatcher falseMatcher = MatchersTestUtils.createTypeMatcher(falsePredicate);
     TypeMatcher unknownMatcher = MatchersTestUtils.createTypeMatcher(unknownPredicate);
 
     TypeMatcher singleTrue = TypeMatchers.any(trueMatcher);
-    assertThat(singleTrue.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.TRUE);
+    assertThat(singleTrue.evaluateFor(expression1, mock())).isEqualTo(TriBool.TRUE);
 
     TypeMatcher bothTrue = TypeMatchers.any(trueMatcher, trueMatcher);
-    assertThat(bothTrue.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.TRUE);
+    assertThat(bothTrue.evaluateFor(expression1, mock())).isEqualTo(TriBool.TRUE);
 
     TypeMatcher falseTrue = TypeMatchers.any(falseMatcher, trueMatcher);
-    assertThat(falseTrue.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.TRUE);
+    assertThat(falseTrue.evaluateFor(expression1, mock())).isEqualTo(TriBool.TRUE);
 
     TypeMatcher trueFalse = TypeMatchers.any(trueMatcher, falseMatcher);
-    assertThat(trueFalse.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.TRUE);
+    assertThat(trueFalse.evaluateFor(expression1, mock())).isEqualTo(TriBool.TRUE);
 
     TypeMatcher trueUnknown = TypeMatchers.any(trueMatcher, unknownMatcher);
-    assertThat(trueUnknown.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.TRUE);
+    assertThat(trueUnknown.evaluateFor(expression1, mock())).isEqualTo(TriBool.TRUE);
 
     TypeMatcher bothUnknown = TypeMatchers.any(unknownMatcher, unknownMatcher);
-    assertThat(bothUnknown.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.UNKNOWN);
+    assertThat(bothUnknown.evaluateFor(expression1, mock())).isEqualTo(TriBool.UNKNOWN);
 
     TypeMatcher falseFalse = TypeMatchers.any(falseMatcher, falseMatcher);
-    assertThat(falseFalse.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.FALSE);
+    assertThat(falseFalse.evaluateFor(expression1, mock())).isEqualTo(TriBool.FALSE);
 
     TypeMatcher falseUnknown = TypeMatchers.any(falseMatcher, unknownMatcher);
-    assertThat(falseUnknown.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.UNKNOWN);
+    assertThat(falseUnknown.evaluateFor(expression1, mock())).isEqualTo(TriBool.UNKNOWN);
 
     TypeMatcher unknownFalse = TypeMatchers.any(falseMatcher, unknownMatcher);
-    assertThat(unknownFalse.evaluateFor(expression1, Mockito.mock())).isEqualTo(TriBool.UNKNOWN);
+    assertThat(unknownFalse.evaluateFor(expression1, mock())).isEqualTo(TriBool.UNKNOWN);
   }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasFQNPredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasFQNPredicateTest.java
index 1d17aa2e47..f63513001e 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasFQNPredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasFQNPredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.types.v2.matchers;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.SubscriptionContext;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.Expression;
@@ -29,49 +28,51 @@
 import org.sonar.python.types.v2.SpecialFormType;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class HasFQNPredicateTest {
 
   @Test
   void testCheck() {
-    FunctionType function1 = Mockito.mock(FunctionType.class);
-    FunctionType function2 = Mockito.mock(FunctionType.class);
-    FunctionType nullFunctionType = Mockito.mock(FunctionType.class);
+    FunctionType function1 = mock(FunctionType.class);
+    FunctionType function2 = mock(FunctionType.class);
+    FunctionType nullFunctionType = mock(FunctionType.class);
 
-    ClassType class1 = Mockito.mock(ClassType.class);
-    ClassType class2 = Mockito.mock(ClassType.class);
-    ClassType classWithSameFQNAsFunction = Mockito.mock(ClassType.class);
+    ClassType class1 = mock(ClassType.class);
+    ClassType class2 = mock(ClassType.class);
+    ClassType classWithSameFQNAsFunction = mock(ClassType.class);
 
-    UnknownType.UnresolvedImportType unresolvedImport = Mockito.mock(UnknownType.UnresolvedImportType.class);
-    UnknownType.UnresolvedImportType unresolvedImport2 = Mockito.mock(UnknownType.UnresolvedImportType.class);
+    UnknownType.UnresolvedImportType unresolvedImport = mock(UnknownType.UnresolvedImportType.class);
+    UnknownType.UnresolvedImportType unresolvedImport2 = mock(UnknownType.UnresolvedImportType.class);
 
-    ModuleType module1 = Mockito.mock(ModuleType.class);
-    ModuleType module2 = Mockito.mock(ModuleType.class);
+    ModuleType module1 = mock(ModuleType.class);
+    ModuleType module2 = mock(ModuleType.class);
 
-    SpecialFormType specialFormType1 = Mockito.mock(SpecialFormType.class);
-    SpecialFormType specialFormType2 = Mockito.mock(SpecialFormType.class);
+    SpecialFormType specialFormType1 = mock(SpecialFormType.class);
+    SpecialFormType specialFormType2 = mock(SpecialFormType.class);
 
-    UnknownType.UnknownTypeImpl unknownType = Mockito.mock(UnknownType.UnknownTypeImpl.class);
+    UnknownType.UnknownTypeImpl unknownType = mock(UnknownType.UnknownTypeImpl.class);
 
-    Expression func1Expression = Mockito.mock(Expression.class);
-    Mockito.when(func1Expression.typeV2()).thenReturn(function1);
+    Expression func1Expression = mock(Expression.class);
+    when(func1Expression.typeV2()).thenReturn(function1);
 
-    Mockito.when(function1.fullyQualifiedName()).thenReturn("foo.bar.func1");
-    Mockito.when(function2.fullyQualifiedName()).thenReturn("foo.bar.func2");
-    Mockito.when(nullFunctionType.fullyQualifiedName()).thenReturn(null);
+    when(function1.fullyQualifiedName()).thenReturn("foo.bar.func1");
+    when(function2.fullyQualifiedName()).thenReturn("foo.bar.func2");
+    when(nullFunctionType.fullyQualifiedName()).thenReturn(null);
 
-    Mockito.when(class1.fullyQualifiedName()).thenReturn("foo.bar.class1");
-    Mockito.when(class2.fullyQualifiedName()).thenReturn("foo.bar.class2");
-    Mockito.when(classWithSameFQNAsFunction.fullyQualifiedName()).thenReturn("foo.bar.func1");
+    when(class1.fullyQualifiedName()).thenReturn("foo.bar.class1");
+    when(class2.fullyQualifiedName()).thenReturn("foo.bar.class2");
+    when(classWithSameFQNAsFunction.fullyQualifiedName()).thenReturn("foo.bar.func1");
 
-    Mockito.when(module1.fullyQualifiedName()).thenReturn("mod.module1");
-    Mockito.when(module2.fullyQualifiedName()).thenReturn("mod.module2");
+    when(module1.fullyQualifiedName()).thenReturn("mod.module1");
+    when(module2.fullyQualifiedName()).thenReturn("mod.module2");
 
-    Mockito.when(specialFormType1.fullyQualifiedName()).thenReturn("typing.List");
-    Mockito.when(specialFormType2.fullyQualifiedName()).thenReturn("typing.Set");
+    when(specialFormType1.fullyQualifiedName()).thenReturn("typing.List");
+    when(specialFormType2.fullyQualifiedName()).thenReturn("typing.Set");
 
-    Mockito.when(unresolvedImport.importPath()).thenReturn("imported.module1");
-    Mockito.when(unresolvedImport2.importPath()).thenReturn("imported.module2");
+    when(unresolvedImport.importPath()).thenReturn("imported.module1");
+    when(unresolvedImport2.importPath()).thenReturn("imported.module2");
 
     HasFQNPredicate hasFQNPredicateFunction1 = new HasFQNPredicate("foo.bar.func1");
     HasFQNPredicate hasFQNPredicateClass1 = new HasFQNPredicate("foo.bar.class1");
@@ -79,8 +80,8 @@ void testCheck() {
     HasFQNPredicate hasFQNPredicateModule1 = new HasFQNPredicate("mod.module1");
     HasFQNPredicate hasFQNPredicateSpecialFormList = new HasFQNPredicate("typing.List");
 
-    TypePredicateContext predicateContext = TypePredicateContext.of(Mockito.mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
-    SubscriptionContext subscriptionContext = Mockito.mock(SubscriptionContext.class);
+    TypePredicateContext predicateContext = TypePredicateContext.of(mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
+    SubscriptionContext subscriptionContext = mock(SubscriptionContext.class);
 
     assertThat(hasFQNPredicateFunction1.check(function1, predicateContext)).isEqualTo(TriBool.TRUE);
     assertThat(TypeMatchers.withFQN("foo.bar.func1").evaluateFor(func1Expression, subscriptionContext)).isEqualTo(TriBool.TRUE);
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasFQNSatisfyingPredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasFQNSatisfyingPredicateTest.java
new file mode 100644
index 0000000000..df46e0ecac
--- /dev/null
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasFQNSatisfyingPredicateTest.java
@@ -0,0 +1,73 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.types.v2.matchers;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.plugins.python.api.SubscriptionContext;
+import org.sonar.plugins.python.api.TriBool;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.types.v2.FunctionType;
+import org.sonar.plugins.python.api.types.v2.UnknownType;
+import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers;
+import org.sonar.python.semantic.v2.typetable.TypeTable;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class HasFQNSatisfyingPredicateTest {
+
+  @Test
+  void testCheck() {
+    FunctionType numpyZeros = mock(FunctionType.class);
+    FunctionType numpyRandom = mock(FunctionType.class);
+    FunctionType other = mock(FunctionType.class);
+    FunctionType nullFqn = mock(FunctionType.class);
+    UnknownType.UnresolvedImportType unresolvedNumpy = mock(UnknownType.UnresolvedImportType.class);
+    UnknownType.UnresolvedImportType unresolvedOther = mock(UnknownType.UnresolvedImportType.class);
+    UnknownType.UnknownTypeImpl unknownType = mock(UnknownType.UnknownTypeImpl.class);
+
+    when(numpyZeros.fullyQualifiedName()).thenReturn("numpy.zeros");
+    when(numpyRandom.fullyQualifiedName()).thenReturn("numpy.random.randn");
+    when(other.fullyQualifiedName()).thenReturn("pandas.Series");
+    when(nullFqn.fullyQualifiedName()).thenReturn(null);
+    when(unresolvedNumpy.importPath()).thenReturn("numpy.polynomial.legendre.legval");
+    when(unresolvedOther.importPath()).thenReturn("numpyish.zeros");
+
+    Expression numpyZerosExpr = mock(Expression.class);
+    when(numpyZerosExpr.typeV2()).thenReturn(numpyZeros);
+
+    HasFQNSatisfyingPredicate predicate = new HasFQNSatisfyingPredicate(
+      typeFqn -> typeFqn.startsWith("numpy.") ? TriBool.TRUE : TriBool.FALSE);
+    TypePredicateContext predicateContext = TypePredicateContext.of(mock(TypeTable.class));
+    SubscriptionContext subscriptionContext = mock(SubscriptionContext.class);
+
+    assertThat(predicate.check(numpyZeros, predicateContext)).isEqualTo(TriBool.TRUE);
+    assertThat(predicate.check(numpyRandom, predicateContext)).isEqualTo(TriBool.TRUE);
+    assertThat(predicate.check(unresolvedNumpy, predicateContext)).isEqualTo(TriBool.TRUE);
+    assertThat(predicate.check(other, predicateContext)).isEqualTo(TriBool.FALSE);
+    assertThat(predicate.check(unresolvedOther, predicateContext)).isEqualTo(TriBool.FALSE);
+    assertThat(predicate.check(nullFqn, predicateContext)).isEqualTo(TriBool.UNKNOWN);
+    assertThat(predicate.check(unknownType, predicateContext)).isEqualTo(TriBool.UNKNOWN);
+
+    assertThat(TypeMatchers.withFQNPrefix("numpy.").evaluateFor(numpyZerosExpr, subscriptionContext))
+      .isEqualTo(TriBool.TRUE);
+    assertThat(TypeMatchers.withFQNSatisfying(typeFqn -> typeFqn.contains("zeros") ? TriBool.TRUE : TriBool.FALSE)
+      .evaluateFor(numpyZerosExpr, subscriptionContext))
+      .isEqualTo(TriBool.TRUE);
+  }
+}
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasMemberPredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasMemberPredicateTest.java
index e2cf2dc911..7b2a831b41 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasMemberPredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/HasMemberPredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.types.v2.matchers;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.SubscriptionContext;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.Expression;
@@ -29,6 +28,9 @@
 import org.sonar.python.semantic.v2.TestProject;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class HasMemberPredicateTest {
 
@@ -46,8 +48,8 @@ def foo(self):
       a
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
     TypePredicateContext predicateContext = TypePredicateContext.of(project.projectLevelTypeTable());
 
     HasMemberPredicate hasFooTypePredicate = new HasMemberPredicate("foo");
@@ -63,12 +65,12 @@ def foo(self):
 
     assertThat(objectType).isNotInstanceOf(UnknownType.class);
 
-    TypePredicate truePredicate = Mockito.mock(TypePredicate.class);
-    TypePredicate falsePredicate = Mockito.mock(TypePredicate.class);
-    TypePredicate unknownPredicate = Mockito.mock(TypePredicate.class);
-    Mockito.when(truePredicate.check(Mockito.any(), Mockito.any())).thenReturn(TriBool.TRUE);
-    Mockito.when(falsePredicate.check(Mockito.any(), Mockito.any())).thenReturn(TriBool.FALSE);
-    Mockito.when(unknownPredicate.check(Mockito.any(), Mockito.any())).thenReturn(TriBool.UNKNOWN);
+    TypePredicate truePredicate = mock(TypePredicate.class);
+    TypePredicate falsePredicate = mock(TypePredicate.class);
+    TypePredicate unknownPredicate = mock(TypePredicate.class);
+    when(truePredicate.check(any(), any())).thenReturn(TriBool.TRUE);
+    when(falsePredicate.check(any(), any())).thenReturn(TriBool.FALSE);
+    when(unknownPredicate.check(any(), any())).thenReturn(TriBool.UNKNOWN);
 
     TypeMatcher trueMatcher = MatchersTestUtils.createTypeMatcher(truePredicate);
     TypeMatcher falseMatcher = MatchersTestUtils.createTypeMatcher(falsePredicate);
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsAnyTypeInUnionSatisfyingTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsAnyTypeInUnionSatisfyingTest.java
index eb322bea56..406d835c60 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsAnyTypeInUnionSatisfyingTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsAnyTypeInUnionSatisfyingTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,7 +21,6 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.types.v2.PythonType;
 import org.sonar.plugins.python.api.types.v2.UnionType;
@@ -30,17 +29,22 @@
 import org.sonar.python.semantic.v2.typetable.TypeTable;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
 
 class IsAnyTypeInUnionSatisfyingTest {
 
   @Test
   void testUnionTypeWithOneMatchingCandidate() {
-    PythonType candidate1 = Mockito.mock(PythonType.class);
-    PythonType candidate2 = Mockito.mock(PythonType.class);
+    PythonType candidate1 = mock(PythonType.class);
+    PythonType candidate2 = mock(PythonType.class);
     UnionType unionType = (UnionType) UnionType.or(candidate1, candidate2);
 
     TypePredicate wrappedPredicate = MatchersTestUtils.mockPredicateReturning(candidate1, TriBool.TRUE);
-    Mockito.when(wrappedPredicate.check(Mockito.eq(candidate2), Mockito.any())).thenReturn(TriBool.FALSE);
+    when(wrappedPredicate.check(eq(candidate2), any())).thenReturn(TriBool.FALSE);
 
     TriBool result = checkType(unionType, wrappedPredicate);
     assertThat(result).isEqualTo(TriBool.TRUE);
@@ -48,12 +52,12 @@ void testUnionTypeWithOneMatchingCandidate() {
 
   @Test
   void testUnionTypeWithAllNonMatchingCandidates() {
-    PythonType candidate1 = Mockito.mock(PythonType.class);
-    PythonType candidate2 = Mockito.mock(PythonType.class);
+    PythonType candidate1 = mock(PythonType.class);
+    PythonType candidate2 = mock(PythonType.class);
     UnionType unionType = (UnionType) UnionType.or(candidate1, candidate2);
 
     TypePredicate wrappedPredicate = MatchersTestUtils.mockPredicateReturning(candidate1, TriBool.FALSE);
-    Mockito.when(wrappedPredicate.check(Mockito.eq(candidate2), Mockito.any())).thenReturn(TriBool.FALSE);
+    when(wrappedPredicate.check(eq(candidate2), any())).thenReturn(TriBool.FALSE);
 
     TriBool result = checkType(unionType, wrappedPredicate);
     assertThat(result).isEqualTo(TriBool.FALSE);
@@ -61,12 +65,12 @@ void testUnionTypeWithAllNonMatchingCandidates() {
 
   @Test
   void testUnionTypeWithUnknownCandidate() {
-    PythonType candidate1 = Mockito.mock(PythonType.class);
-    PythonType candidate2 = Mockito.mock(PythonType.class);
+    PythonType candidate1 = mock(PythonType.class);
+    PythonType candidate2 = mock(PythonType.class);
     UnionType unionType = (UnionType) UnionType.or(candidate1, candidate2);
 
     TypePredicate wrappedPredicate = MatchersTestUtils.mockPredicateReturning(candidate1, TriBool.FALSE);
-    Mockito.when(wrappedPredicate.check(Mockito.eq(candidate2), Mockito.any())).thenReturn(TriBool.UNKNOWN);
+    when(wrappedPredicate.check(eq(candidate2), any())).thenReturn(TriBool.UNKNOWN);
 
     TriBool result = checkType(unionType, wrappedPredicate);
     assertThat(result).isEqualTo(TriBool.UNKNOWN);
@@ -76,25 +80,25 @@ void testUnionTypeWithUnknownCandidate() {
   @ParameterizedTest
   @MethodSource("nonUnionTypesWithExpectedResults")
   void testNonUnionTypeDoesNotDelegateToWrappedPredicate(PythonType nonUnionType, TriBool expectedResult) {
-    TypePredicate wrappedPredicate = Mockito.mock(TypePredicate.class);
+    TypePredicate wrappedPredicate = mock(TypePredicate.class);
 
     TriBool result = checkType(nonUnionType, wrappedPredicate);
 
     assertThat(result).isEqualTo(expectedResult);
-    Mockito.verifyNoInteractions(wrappedPredicate);
+    verifyNoInteractions(wrappedPredicate);
   }
 
   static Stream nonUnionTypesWithExpectedResults() {
     return Stream.of(
       Arguments.of(PythonType.UNKNOWN, TriBool.UNKNOWN),
       Arguments.of(new UnknownType.UnresolvedImportType("some.module"), TriBool.UNKNOWN),
-      Arguments.of(Mockito.mock(PythonType.class), TriBool.FALSE)
+      Arguments.of(mock(PythonType.class), TriBool.FALSE)
     );
   }
 
   private static TriBool checkType(PythonType type, TypePredicate wrappedPredicate) {
     IsAnyTypeInUnionSatisfying predicate = new IsAnyTypeInUnionSatisfying(wrappedPredicate);
-    TypePredicateContext ctx = TypePredicateContext.of(Mockito.mock(TypeTable.class));
+    TypePredicateContext ctx = TypePredicateContext.of(mock(TypeTable.class));
     return predicate.check(type, ctx);
   }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsFunctionOwnerSatisfyingPredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsFunctionOwnerSatisfyingPredicateTest.java
index 20d24a46c5..11ce379c43 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsFunctionOwnerSatisfyingPredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsFunctionOwnerSatisfyingPredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.types.v2.matchers;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.Expression;
 import org.sonar.plugins.python.api.tree.FunctionDef;
@@ -31,6 +30,8 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.sonar.python.types.v2.TypesTestUtils.PROJECT_LEVEL_TYPE_TABLE;
 import static org.sonar.python.types.v2.TypesTestUtils.parseAndInferTypes;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class IsFunctionOwnerSatisfyingPredicateTest {
 
@@ -109,8 +110,8 @@ class MyClass:
   @Test
   void testUnknownType() {
     var project = new TestProject();
-    Expression unknownTypeExpression = Mockito.mock(Expression.class);
-    Mockito.when(unknownTypeExpression.typeV2()).thenReturn(PythonType.UNKNOWN);
+    Expression unknownTypeExpression = mock(Expression.class);
+    when(unknownTypeExpression.typeV2()).thenReturn(PythonType.UNKNOWN);
 
     TypePredicateContext ctx = TypePredicateContext.of(project.projectLevelTypeTable());
 
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsObjectSatisfyingPredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsObjectSatisfyingPredicateTest.java
index bc8c2e83d2..d81abe9416 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsObjectSatisfyingPredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsObjectSatisfyingPredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,7 +21,6 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.types.v2.ObjectType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
@@ -32,13 +31,15 @@
 import org.sonar.python.semantic.v2.typetable.TypeTable;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
 
 class IsObjectSatisfyingPredicateTest {
 
   @ParameterizedTest
   @MethodSource("objectTypeWithWrappedPredicateResults")
   void testObjectTypeUnwrapsAndDelegatesToWrappedPredicate(TriBool wrappedPredicateResult, TriBool expectedResult) {
-    PythonType wrappedType = Mockito.mock(PythonType.class);
+    PythonType wrappedType = mock(PythonType.class);
     ObjectType objectType = ObjectType.fromType(wrappedType);
     TypePredicate wrappedPredicate = MatchersTestUtils.mockPredicateReturning(wrappedType, wrappedPredicateResult);
 
@@ -57,12 +58,12 @@ static Stream objectTypeWithWrappedPredicateResults() {
   @ParameterizedTest
   @MethodSource("nonObjectTypesWithExpectedResults")
   void testNonObjectTypeDoesNotDelegateToWrappedPredicate(PythonType nonObjectType, TriBool expectedResult) {
-    TypePredicate wrappedPredicate = Mockito.mock(TypePredicate.class);
+    TypePredicate wrappedPredicate = mock(TypePredicate.class);
 
     TriBool result = checkType(nonObjectType, wrappedPredicate);
 
     assertThat(result).isEqualTo(expectedResult);
-    Mockito.verifyNoInteractions(wrappedPredicate);
+    verifyNoInteractions(wrappedPredicate);
   }
 
 
@@ -70,13 +71,13 @@ static Stream nonObjectTypesWithExpectedResults() {
     return Stream.of(
       Arguments.of(PythonType.UNKNOWN, TriBool.UNKNOWN),
       Arguments.of(new UnknownType.UnresolvedImportType("some.module"), TriBool.UNKNOWN),
-      Arguments.of(Mockito.mock(PythonType.class), TriBool.FALSE)
+      Arguments.of(mock(PythonType.class), TriBool.FALSE)
     );
   }
 
   @Test
   void testTypeMatchersIsObjectSatisfyingIntegration() {
-    PythonType wrappedType = Mockito.mock(PythonType.class);
+    PythonType wrappedType = mock(PythonType.class);
     ObjectType objectType = ObjectType.fromType(wrappedType);
 
     TypePredicate innerPredicate = MatchersTestUtils.mockPredicateReturning(wrappedType, TriBool.TRUE);
@@ -84,7 +85,7 @@ void testTypeMatchersIsObjectSatisfyingIntegration() {
 
     TypeMatcher objectThatMatcher = TypeMatchers.isObjectSatisfying(innerMatcher);
 
-    TypePredicateContext ctx = Mockito.mock(TypePredicateContext.class);
+    TypePredicateContext ctx = mock(TypePredicateContext.class);
     TriBool result = MatchersTestUtils.getPredicate(objectThatMatcher).check(objectType, ctx);
 
     assertThat(result).isEqualTo(TriBool.TRUE);
@@ -92,7 +93,7 @@ void testTypeMatchersIsObjectSatisfyingIntegration() {
 
   private static TriBool checkType(PythonType type, TypePredicate wrappedPredicate) {
     IsObjectSatisfyingPredicate predicate = new IsObjectSatisfyingPredicate(wrappedPredicate);
-    TypePredicateContext ctx = TypePredicateContext.of(Mockito.mock(TypeTable.class));
+    TypePredicateContext ctx = TypePredicateContext.of(mock(TypeTable.class));
     return predicate.check(type, ctx);
   }
 }
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsSelfTypePredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsSelfTypePredicateTest.java
index aa3e2d09ca..dce0eca434 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsSelfTypePredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsSelfTypePredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.types.v2.matchers;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.types.v2.ClassType;
 import org.sonar.plugins.python.api.types.v2.ObjectType;
@@ -26,16 +25,18 @@
 import org.sonar.plugins.python.api.types.v2.UnknownType;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class IsSelfTypePredicateTest {
 
   private final IsSelfTypePredicate predicate = new IsSelfTypePredicate();
   private final TypePredicateContext ctx = TypePredicateContext.of(
-    Mockito.mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
+    mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
 
   @Test
   void selfTypeReturnsTrue() {
-    ClassType innerType = Mockito.mock(ClassType.class);
+    ClassType innerType = mock(ClassType.class);
     SelfType selfType = (SelfType) SelfType.of(innerType);
 
     assertThat(predicate.check(selfType, ctx)).isEqualTo(TriBool.TRUE);
@@ -43,16 +44,16 @@ void selfTypeReturnsTrue() {
 
   @Test
   void objectTypeWrappingSelfTypeReturnsFalse() {
-    ObjectType objectType = Mockito.mock(ObjectType.class);
-    SelfType selfType = Mockito.mock(SelfType.class);
-    Mockito.when(objectType.type()).thenReturn(selfType);
+    ObjectType objectType = mock(ObjectType.class);
+    SelfType selfType = mock(SelfType.class);
+    when(objectType.type()).thenReturn(selfType);
 
     assertThat(predicate.check(objectType, ctx)).isEqualTo(TriBool.FALSE);
   }
 
   @Test
   void classTypeReturnsFalse() {
-    ClassType classType = Mockito.mock(ClassType.class);
+    ClassType classType = mock(ClassType.class);
 
     assertThat(predicate.check(classType, ctx)).isEqualTo(TriBool.FALSE);
   }
@@ -64,17 +65,17 @@ void unknownTypeReturnsUnknown() {
 
   @Test
   void unresolvedImportTypeReturnsUnknown() {
-    UnknownType.UnresolvedImportType unresolvedImportType = Mockito.mock(UnknownType.UnresolvedImportType.class);
+    UnknownType.UnresolvedImportType unresolvedImportType = mock(UnknownType.UnresolvedImportType.class);
 
     assertThat(predicate.check(unresolvedImportType, ctx)).isEqualTo(TriBool.UNKNOWN);
   }
 
   @Test
   void compositionWithIsObjectSatisfying() {
-    ClassType innerType = Mockito.mock(ClassType.class);
+    ClassType innerType = mock(ClassType.class);
     SelfType selfType = (SelfType) SelfType.of(innerType);
-    ObjectType objectType = Mockito.mock(ObjectType.class);
-    Mockito.when(objectType.unwrappedType()).thenReturn(selfType);
+    ObjectType objectType = mock(ObjectType.class);
+    when(objectType.unwrappedType()).thenReturn(selfType);
 
     TypePredicate isObjectOfSelf = new IsObjectSatisfyingPredicate(predicate);
 
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsTypeOrSuperTypeSatisfyingPredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsTypeOrSuperTypeSatisfyingPredicateTest.java
index e5d5a4daa0..2499591374 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsTypeOrSuperTypeSatisfyingPredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsTypeOrSuperTypeSatisfyingPredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.types.v2.matchers;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.SubscriptionContext;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.Expression;
@@ -28,6 +27,8 @@
 import org.sonar.python.semantic.v2.TestProject;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class IsTypeOrSuperTypeSatisfyingPredicateTest {
 
@@ -43,8 +44,8 @@ class A:
       A()
       """);
 
-    SubscriptionContext subscriptionContext = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext subscriptionContext = mock(SubscriptionContext.class);
+    when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     assertThat(TypeMatchers.isObjectInstanceOf("my_file.A").evaluateFor(objectTypeExpression, subscriptionContext)).isEqualTo(TriBool.TRUE);
     assertThat(TypeMatchers.isObjectInstanceOf("str").evaluateFor(objectTypeExpression, subscriptionContext)).isEqualTo(TriBool.FALSE);
@@ -66,8 +67,8 @@ class C(A):
       B()
       """);
 
-    SubscriptionContext subscriptionContext = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext subscriptionContext = mock(SubscriptionContext.class);
+    when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     assertThat(TypeMatchers.isObjectInstanceOf("my_file.A").evaluateFor(objectTypeExpression, subscriptionContext)).isEqualTo(TriBool.TRUE);
     assertThat(TypeMatchers.isObjectInstanceOf("my_file.B").evaluateFor(objectTypeExpression, subscriptionContext)).isEqualTo(TriBool.TRUE);
@@ -89,8 +90,8 @@ class A:
 
     TypePredicateContext ctx = TypePredicateContext.of(project.projectLevelTypeTable());
 
-    SubscriptionContext subscriptionContext = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext subscriptionContext = mock(SubscriptionContext.class);
+    when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     var predicate = new IsTypeOrSuperTypeSatisfyingPredicate(new IsTypePredicate("my_file.A"));
 
@@ -114,8 +115,8 @@ class B(A):
 
     TypePredicateContext ctx = TypePredicateContext.of(project.projectLevelTypeTable());
 
-    SubscriptionContext subscriptionContext = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext subscriptionContext = mock(SubscriptionContext.class);
+    when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     var predicateA = new IsTypeOrSuperTypeSatisfyingPredicate(new IsTypePredicate("my_file.A"));
     var predicateB = new IsTypeOrSuperTypeSatisfyingPredicate(new IsTypePredicate("my_file.B"));
@@ -206,8 +207,8 @@ class A:
 
     TypePredicateContext ctx = TypePredicateContext.of(project.projectLevelTypeTable());
 
-    SubscriptionContext subscriptionContext = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext subscriptionContext = mock(SubscriptionContext.class);
+    when(subscriptionContext.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     var predicate = new IsTypeOrSuperTypeSatisfyingPredicate(new HasFQNPredicate("my_file.A"));
 
@@ -239,8 +240,8 @@ class B(A):
   @Test
   void testUnknownType() {
     var project = new TestProject();
-    Expression unknownTypeExpression = Mockito.mock(Expression.class);
-    Mockito.when(unknownTypeExpression.typeV2()).thenReturn(PythonType.UNKNOWN);
+    Expression unknownTypeExpression = mock(Expression.class);
+    when(unknownTypeExpression.typeV2()).thenReturn(PythonType.UNKNOWN);
 
     TypePredicateContext ctx = TypePredicateContext.of(project.projectLevelTypeTable());
 
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsTypePredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsTypePredicateTest.java
index 38a306673a..86d97a25d8 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsTypePredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/IsTypePredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +17,6 @@
 package org.sonar.python.types.v2.matchers;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.SubscriptionContext;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.tree.Expression;
@@ -29,6 +28,8 @@
 import org.sonar.python.semantic.v2.typetable.TypeTable;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class IsTypePredicateTest {
 
@@ -49,8 +50,8 @@ def __init__(self):
       a
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
     TypePredicateContext predicateContext = TypePredicateContext.of(project.projectLevelTypeTable());
 
     IsTypePredicate isTypeAPredicate = new IsTypePredicate("my_file.A");
@@ -78,8 +79,8 @@ def __init__(self):
       A
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
     TypePredicateContext predicateContext = TypePredicateContext.of(project.projectLevelTypeTable());
 
     IsTypePredicate isTypeAPredicate = new IsTypePredicate("my_file.A");
@@ -112,8 +113,8 @@ def __init__(self):
       a
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
     TypePredicateContext predicateContext = TypePredicateContext.of(project.projectLevelTypeTable());
 
     IsTypePredicate isTypeAPredicate = new IsTypePredicate("my_file.A");
@@ -139,8 +140,8 @@ def __init__(self):
       A
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     assertThat(TypeMatchers.isType("my_file.A").isTrueFor(classTypeExpression, ctx)).isTrue();
     assertThat(TypeMatchers.isType("my_file.B").isTrueFor(classTypeExpression, ctx)).isFalse();
@@ -166,8 +167,8 @@ def __init__(self):
       A # will result the class A defined in package/A.py
       """);
 
-    SubscriptionContext ctx = Mockito.mock(SubscriptionContext.class);
-    Mockito.when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
+    SubscriptionContext ctx = mock(SubscriptionContext.class);
+    when(ctx.typeTable()).thenReturn(project.projectLevelTypeTable());
 
     // isType(fqn) resolves the FQN like "import package.A.A" which will prefer the class A defined in __init__.py
     assertThat(TypeMatchers.isType("package.A.A").evaluateFor(classTypeExpression, ctx)).isEqualTo(TriBool.FALSE);
@@ -192,9 +193,9 @@ class A:
     
     assertThat(isTypePredicate.check(selfType, ctx)).isEqualTo(TriBool.UNKNOWN);
     
-    var mockTypeTable = Mockito.mock(TypeTable.class);
+    var mockTypeTable = mock(TypeTable.class);
     // mocking this to improve coverage, should normally never happen
-    Mockito.when(mockTypeTable.getType("my_file.A")).thenReturn(selfType);
+    when(mockTypeTable.getType("my_file.A")).thenReturn(selfType);
 
     ctx = TypePredicateContext.of(mockTypeTable);
     assertThat(isTypePredicate.check(classTypeExpression.typeV2(), ctx)).isEqualTo(TriBool.UNKNOWN);
diff --git a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/TypeSourcePredicateTest.java b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/TypeSourcePredicateTest.java
index 766f5c046c..f75f6dad9c 100644
--- a/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/TypeSourcePredicateTest.java
+++ b/python-frontend/src/test/java/org/sonar/python/types/v2/matchers/TypeSourcePredicateTest.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,7 +21,6 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mockito;
 import org.sonar.plugins.python.api.TriBool;
 import org.sonar.plugins.python.api.types.v2.ObjectType;
 import org.sonar.plugins.python.api.types.v2.PythonType;
@@ -30,6 +29,8 @@
 import org.sonar.plugins.python.api.types.v2.matchers.TypeMatchers;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class TypeSourcePredicateTest {
 
@@ -38,7 +39,7 @@ class TypeSourcePredicateTest {
   void testMatchingTypeSources(TypeSource typeSource) {
     PythonType type = createTypeWithSource(typeSource);
     TypeSourcePredicate predicate = new TypeSourcePredicate(typeSource);
-    TypePredicateContext ctx = TypePredicateContext.of(Mockito.mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
+    TypePredicateContext ctx = TypePredicateContext.of(mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
 
     assertThat(predicate.check(type, ctx)).isEqualTo(TriBool.TRUE);
   }
@@ -48,7 +49,7 @@ void testMatchingTypeSources(TypeSource typeSource) {
   void testNonMatchingTypeSources(TypeSource typeTypeSource, TypeSource predicateTypeSource) {
     PythonType type = createTypeWithSource(typeTypeSource);
     TypeSourcePredicate predicate = new TypeSourcePredicate(predicateTypeSource);
-    TypePredicateContext ctx = TypePredicateContext.of(Mockito.mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
+    TypePredicateContext ctx = TypePredicateContext.of(mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
 
     assertThat(predicate.check(type, ctx)).isEqualTo(TriBool.FALSE);
   }
@@ -57,7 +58,7 @@ void testNonMatchingTypeSources(TypeSource typeTypeSource, TypeSource predicateT
   void testThroughTypeMatchers() {
     PythonType typeWithExactSource = createTypeWithSource(TypeSource.EXACT);
     PythonType typeWithTypeHintSource = createTypeWithSource(TypeSource.TYPE_HINT);
-    TypePredicateContext predicateContext = TypePredicateContext.of(Mockito.mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
+    TypePredicateContext predicateContext = TypePredicateContext.of(mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
 
     assertThat(MatchersTestUtils.getPredicate(TypeMatchers.hasTypeSource(TypeSource.EXACT)).check(typeWithExactSource, predicateContext)).isEqualTo(TriBool.TRUE);
     assertThat(MatchersTestUtils.getPredicate(TypeMatchers.hasTypeSource(TypeSource.EXACT)).check(typeWithTypeHintSource, predicateContext)).isEqualTo(TriBool.FALSE);
@@ -69,13 +70,13 @@ void testThroughTypeMatchers() {
   void testObjectTypeIsNotUnwrapped() {
     PythonType wrappedType = createTypeWithSource(TypeSource.TYPE_HINT);
 
-    ObjectType objectType = Mockito.mock(ObjectType.class);
-    Mockito.when(objectType.typeSource()).thenReturn(TypeSource.EXACT);
-    Mockito.when(objectType.unwrappedType()).thenReturn(wrappedType);
+    ObjectType objectType = mock(ObjectType.class);
+    when(objectType.typeSource()).thenReturn(TypeSource.EXACT);
+    when(objectType.unwrappedType()).thenReturn(wrappedType);
 
     TypeSourcePredicate exactPredicate = new TypeSourcePredicate(TypeSource.EXACT);
     TypeSourcePredicate typeHintPredicate = new TypeSourcePredicate(TypeSource.TYPE_HINT);
-    TypePredicateContext ctx = TypePredicateContext.of(Mockito.mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
+    TypePredicateContext ctx = TypePredicateContext.of(mock(org.sonar.python.semantic.v2.typetable.TypeTable.class));
 
     assertThat(exactPredicate.check(objectType, ctx)).isEqualTo(TriBool.TRUE);
     assertThat(typeHintPredicate.check(objectType, ctx)).isEqualTo(TriBool.FALSE);
@@ -93,8 +94,8 @@ private static Stream nonMatchingTypeSourceCases() {
   }
 
   private static PythonType createTypeWithSource(TypeSource typeSource) {
-    PythonType type = Mockito.mock(PythonType.class);
-    Mockito.when(type.typeSource()).thenReturn(typeSource);
+    PythonType type = mock(PythonType.class);
+    when(type.typeSource()).thenReturn(typeSource);
     return type;
   }
 }
diff --git a/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_array_with_empty_string_source.ipynb b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_array_with_empty_string_source.ipynb
new file mode 100644
index 0000000000..f00f4b0008
--- /dev/null
+++ b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_array_with_empty_string_source.ipynb
@@ -0,0 +1,29 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": "x = 1"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        ""
+      ]
+    }
+  ],
+  "metadata": {
+    "language_info": {
+      "name": "python"
+    },
+    "name": "test",
+    "notebookId": 1
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_empty_array_source.ipynb b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_empty_array_source.ipynb
new file mode 100644
index 0000000000..da47bf1d14
--- /dev/null
+++ b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_empty_array_source.ipynb
@@ -0,0 +1,27 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": "x = 1"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "language_info": {
+      "name": "python"
+    },
+    "name": "test",
+    "notebookId": 1
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_empty_string_source.ipynb b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_empty_string_source.ipynb
new file mode 100644
index 0000000000..fe57ce65a9
--- /dev/null
+++ b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_empty_string_source.ipynb
@@ -0,0 +1,27 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": "x = 1"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": ""
+    }
+  ],
+  "metadata": {
+    "language_info": {
+      "name": "python"
+    },
+    "name": "test",
+    "notebookId": 1
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array.ipynb b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array.ipynb
new file mode 100644
index 0000000000..8c14af6945
--- /dev/null
+++ b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array.ipynb
@@ -0,0 +1,22 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(\"Test 1\")\ntestA = \"1\"\nprint(\"Test 2\")\ntestB = \"2\"\nprint(\"Test 3\")\ntestC = \"3\"\n\n\ntestAll = testA + testB + testC\n\nprint(testAll)"
+      ]
+    }
+  ],
+  "metadata": {
+    "language_info": {
+      "name": "python"
+    },
+    "name": "test",
+    "notebookId": 1
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array_no_trailing_newline.ipynb b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array_no_trailing_newline.ipynb
new file mode 100644
index 0000000000..a27406576a
--- /dev/null
+++ b/python-frontend/src/test/resources/org/sonar/plugins/python/notebook_multiline_string_in_array_no_trailing_newline.ipynb
@@ -0,0 +1,23 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 0,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "x = 1\ny",
+        " = 2"
+      ]
+    }
+  ],
+  "metadata": {
+    "language_info": {
+      "name": "python"
+    },
+    "name": "test",
+    "notebookId": 1
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/python-frontend/typeshed_serializer/README.md b/python-frontend/typeshed_serializer/README.md
index 0468bf6233..1d88658663 100644
--- a/python-frontend/typeshed_serializer/README.md
+++ b/python-frontend/typeshed_serializer/README.md
@@ -32,8 +32,8 @@ tox -e py39 -- tests/runners/test_tox_runner.py::ToxRunnerTest::test_dry_run_unc
 python runners/tox_runner.py --dry_run true 
 ```
 
-Can also be run in fail fast mode, to reflect behaviour in CI (where failStubGenerationFast is true)
+Can also be run in fail fast mode, to reflect the checksum validation used by the QA workflow
 
 ```bash
 python runners/tox_runner.py --dry_run true --fail_fast true  
-```
\ No newline at end of file
+```
diff --git a/python-frontend/typeshed_serializer/checksums/custom.checksum b/python-frontend/typeshed_serializer/checksums/custom.checksum
index 736af910e3..7ee58aadee 100644
--- a/python-frontend/typeshed_serializer/checksums/custom.checksum
+++ b/python-frontend/typeshed_serializer/checksums/custom.checksum
@@ -1,2 +1,2 @@
-5264643196941521a2f81ff6d51c750007ab196d892c0c113697b51b17985c82
-1ce0cddf4561cb6431cb0d5e7e4dbd30c96cfcf6397241185edf2d3ba452aaef
\ No newline at end of file
+242b3df8166ce6738470346be49a63fc492150844cf6a37e1e6282ba69a23420
+8ebc647d7c84f473b699ca1ad2a89e6085ee13f57fa95befcd49a849c927a18f
\ No newline at end of file
diff --git a/python-frontend/typeshed_serializer/checksums/importer.checksum b/python-frontend/typeshed_serializer/checksums/importer.checksum
index 4ed2d949ea..baf0df5e4c 100644
--- a/python-frontend/typeshed_serializer/checksums/importer.checksum
+++ b/python-frontend/typeshed_serializer/checksums/importer.checksum
@@ -1,2 +1,2 @@
 fd77cbe2295d8908b6b4fa54a1ae7d257084790de28f164bd67e4c22e8cd5149
-b9ad5bf1c2bb88ebc44d2516a96b05c68fe2af5b54930919794907c8d71a9caa
\ No newline at end of file
+0bb14b48f2d4349448edf18d406fbc4d5ff4c0c3fcdf6095cae8e5f7729cf5ab
\ No newline at end of file
diff --git a/python-frontend/typeshed_serializer/requirements.txt b/python-frontend/typeshed_serializer/requirements.txt
index c13551d19b..0acb0c9d17 100644
--- a/python-frontend/typeshed_serializer/requirements.txt
+++ b/python-frontend/typeshed_serializer/requirements.txt
@@ -33,8 +33,8 @@ kazoo==2.9.0
 MarkupSafe==2.1.2
 maxminddb==2.3.0
 orjson==3.8.12
-pandas==2.1.1
-pandas-stubs==2.0.3.230814
+pandas==2.2.3
+pandas-stubs==2.2.2.240807
 pathlib==1.0.1
 PyJWT==2.7.0
 PyYAML==6.0.1
diff --git a/python-frontend/typeshed_serializer/resources/custom/_pytest/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/_pytest/__init__.pyi
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/python-frontend/typeshed_serializer/resources/custom/_pytest/fixtures.pyi b/python-frontend/typeshed_serializer/resources/custom/_pytest/fixtures.pyi
new file mode 100644
index 0000000000..f3d859808c
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/_pytest/fixtures.pyi
@@ -0,0 +1,5 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+
+class FixtureRequest(CustomStubBase):
+    def getfixturevalue(self, argname: str) -> object: ...
+    def addfinalizer(self, finalizer: object) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/__init__.pyi
new file mode 100644
index 0000000000..ae112538d7
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/__init__.pyi
@@ -0,0 +1,2 @@
+from airflow.models.dag import DAG
+from airflow.models.baseoperator import BaseOperator
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/decorators/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/decorators/__init__.pyi
new file mode 100644
index 0000000000..d3adc80fc6
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/decorators/__init__.pyi
@@ -0,0 +1,3 @@
+from typing import Any, Callable
+
+def dag(*args, **kwargs) -> Callable[..., Any]: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/models/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/models/__init__.pyi
new file mode 100644
index 0000000000..fab4e551a0
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/models/__init__.pyi
@@ -0,0 +1,3 @@
+from airflow.models.baseoperator import BaseOperator
+from airflow.models.dag import DAG
+from airflow.models.taskmixin import DependencyMixin
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/models/baseoperator.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/models/baseoperator.pyi
new file mode 100644
index 0000000000..98c93400ed
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/models/baseoperator.pyi
@@ -0,0 +1,4 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+
+class BaseOperator(CustomStubBase):
+    def __init__(self, *args, **kwargs) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/models/dag.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/models/dag.pyi
new file mode 100644
index 0000000000..9aa85f1cab
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/models/dag.pyi
@@ -0,0 +1,4 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+
+class DAG(CustomStubBase):
+    def __init__(self, *args, **kwargs) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/models/taskmixin.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/models/taskmixin.pyi
new file mode 100644
index 0000000000..320414a5f9
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/models/taskmixin.pyi
@@ -0,0 +1,4 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+
+class DependencyMixin(CustomStubBase):
+    def __init__(self, *args, **kwargs) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/providers/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/__init__.pyi
new file mode 100644
index 0000000000..814955b0e4
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/__init__.pyi
@@ -0,0 +1,2 @@
+from airflow.providers.amazon.aws.operators.ecs import EcsRunTaskOperator
+from airflow.providers.http.operators.http import HttpOperator
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/__init__.pyi
new file mode 100644
index 0000000000..0c7584143b
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/__init__.pyi
@@ -0,0 +1 @@
+from airflow.providers.amazon.aws.operators.ecs import EcsRunTaskOperator
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/aws/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/aws/__init__.pyi
new file mode 100644
index 0000000000..0c7584143b
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/aws/__init__.pyi
@@ -0,0 +1 @@
+from airflow.providers.amazon.aws.operators.ecs import EcsRunTaskOperator
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/aws/operators/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/aws/operators/__init__.pyi
new file mode 100644
index 0000000000..0c7584143b
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/aws/operators/__init__.pyi
@@ -0,0 +1 @@
+from airflow.providers.amazon.aws.operators.ecs import EcsRunTaskOperator
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/aws/operators/ecs.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/aws/operators/ecs.pyi
new file mode 100644
index 0000000000..6e098bbc82
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/amazon/aws/operators/ecs.pyi
@@ -0,0 +1,4 @@
+from airflow.models.baseoperator import BaseOperator
+
+class EcsRunTaskOperator(BaseOperator):
+    def __init__(self, *args, **kwargs) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/providers/http/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/http/__init__.pyi
new file mode 100644
index 0000000000..c768f3d012
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/http/__init__.pyi
@@ -0,0 +1 @@
+from airflow.providers.http.operators.http import HttpOperator
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/providers/http/operators/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/http/operators/__init__.pyi
new file mode 100644
index 0000000000..c768f3d012
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/http/operators/__init__.pyi
@@ -0,0 +1 @@
+from airflow.providers.http.operators.http import HttpOperator
diff --git a/python-frontend/typeshed_serializer/resources/custom/airflow/providers/http/operators/http.pyi b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/http/operators/http.pyi
new file mode 100644
index 0000000000..a0bbefd434
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/airflow/providers/http/operators/http.pyi
@@ -0,0 +1,4 @@
+from airflow.models.baseoperator import BaseOperator
+
+class HttpOperator(BaseOperator):
+    def __init__(self, *args, **kwargs) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/assertpy/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/assertpy/__init__.pyi
new file mode 100644
index 0000000000..4dafa0c2de
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/assertpy/__init__.pyi
@@ -0,0 +1,9 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+
+class AssertionBuilder(CustomStubBase):
+    def described_as(self, description: str) -> "AssertionBuilder": ...
+    def snapshot(self, name: str) -> "AssertionBuilder": ...
+    def is_equal_to(self, other: object = ...) -> "AssertionBuilder": ...
+    def is_not_equal_to(self, other: object) -> "AssertionBuilder": ...
+
+def assert_that(val: object = ...) -> AssertionBuilder: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/confluent_kafka/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/confluent_kafka/__init__.pyi
new file mode 100644
index 0000000000..1211275764
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/confluent_kafka/__init__.pyi
@@ -0,0 +1 @@
+from confluent_kafka.aio import AIOConsumer
\ No newline at end of file
diff --git a/python-frontend/typeshed_serializer/resources/custom/confluent_kafka/aio/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/confluent_kafka/aio/__init__.pyi
new file mode 100644
index 0000000000..add49994db
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/confluent_kafka/aio/__init__.pyi
@@ -0,0 +1 @@
+from confluent_kafka.aio.consumer import AIOConsumer
\ No newline at end of file
diff --git a/python-frontend/typeshed_serializer/resources/custom/confluent_kafka/aio/consumer.pyi b/python-frontend/typeshed_serializer/resources/custom/confluent_kafka/aio/consumer.pyi
new file mode 100644
index 0000000000..db2f86b400
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/confluent_kafka/aio/consumer.pyi
@@ -0,0 +1,13 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+from typing import Any, Callable, Coroutine, List, Optional
+
+class AIOConsumer(CustomStubBase):
+    def __init__(self, config: dict, **kwargs: Any) -> None: ...
+    async def subscribe(
+        self,
+        topics: List[str],
+        on_assign: Optional[Callable[..., Coroutine[Any, Any, None]]] = ...,
+        on_revoke: Optional[Callable[..., Coroutine[Any, Any, None]]] = ...,
+        on_lost: Optional[Callable[..., Coroutine[Any, Any, None]]] = ...,
+        **kwargs: Any,
+    ) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/__init__.pyi
index 45fdc7bf60..759277930c 100644
--- a/python-frontend/typeshed_serializer/resources/custom/django/__init__.pyi
+++ b/python-frontend/typeshed_serializer/resources/custom/django/__init__.pyi
@@ -4,3 +4,6 @@ import django.utils as utils
 import django.urls as urls
 import django.conf as conf
 import django.apps as apps
+import django.contrib as contrib
+import django.views as views
+import django.contrib as contrib
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/contrib/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/contrib/__init__.pyi
new file mode 100644
index 0000000000..17c37a156b
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/contrib/__init__.pyi
@@ -0,0 +1 @@
+import django.contrib.auth as auth
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/contrib/auth/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/contrib/auth/__init__.pyi
new file mode 100644
index 0000000000..32af52e1fc
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/contrib/auth/__init__.pyi
@@ -0,0 +1,10 @@
+import django.contrib.auth.middleware as middleware
+import django.contrib.auth.models as models
+
+from .models import (
+    AbstractBaseUser as AbstractBaseUser,
+    AbstractUser as AbstractUser,
+    AnonymousUser as AnonymousUser,
+    User as User,
+    UserManager as UserManager,
+)
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/contrib/auth/middleware.pyi b/python-frontend/typeshed_serializer/resources/custom/django/contrib/auth/middleware.pyi
new file mode 100644
index 0000000000..fb49ae0595
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/contrib/auth/middleware.pyi
@@ -0,0 +1,9 @@
+from typing import Any, Callable
+
+class RemoteUserMiddleware:
+    header: str
+    force_logout_if_no_header: bool
+    def __init__(self, get_response: Callable[..., Any]) -> None: ...
+    def __call__(self, request: Any) -> Any: ...
+
+class PersistentRemoteUserMiddleware(RemoteUserMiddleware): ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/contrib/auth/models.pyi b/python-frontend/typeshed_serializer/resources/custom/django/contrib/auth/models.pyi
new file mode 100644
index 0000000000..ef9351c374
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/contrib/auth/models.pyi
@@ -0,0 +1,36 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+from django.db.models.base import Model
+from django.db.models.manager import Manager
+from typing import Any
+
+class UserManager(Manager):
+    def create(self, **kwargs: Any) -> "AbstractBaseUser": ...
+    def create_user(
+        self,
+        username: str,
+        email: str | None = None,
+        password: str | None = None,
+        **extra_fields: Any,
+    ) -> "AbstractBaseUser": ...
+    def create_superuser(
+        self,
+        username: str,
+        email: str | None = None,
+        password: str | None = None,
+        **extra_fields: Any,
+    ) -> "AbstractBaseUser": ...
+
+class AbstractBaseUser(Model, CustomStubBase):
+    password: str
+    def set_password(self, raw_password: str) -> None: ...
+    def check_password(self, raw_password: str) -> bool: ...
+
+class AbstractUser(AbstractBaseUser):
+    username: str
+    email: str
+    objects: UserManager
+
+class User(AbstractUser):
+    objects: UserManager
+
+class AnonymousUser(CustomStubBase): ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/core/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/core/__init__.pyi
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/core/management/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/core/management/__init__.pyi
new file mode 100644
index 0000000000..5ff268b687
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/core/management/__init__.pyi
@@ -0,0 +1 @@
+from django.core.management.base import BaseCommand as BaseCommand
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/core/management/base.pyi b/python-frontend/typeshed_serializer/resources/custom/django/core/management/base.pyi
new file mode 100644
index 0000000000..4d284c95ee
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/core/management/base.pyi
@@ -0,0 +1,39 @@
+from typing import Any, IO, Sequence, Set, Tuple
+import argparse
+from django.core.management.base import SystemCheckError
+
+class BaseCommand:
+    # Metadata about this command.
+    help: str
+
+    # Configuration shortcuts that alter various logic.
+    _called_from_command_line: bool
+    output_transaction: bool  # Whether to wrap the output in a "BEGIN; COMMIT;"
+    requires_migrations_checks: bool
+    requires_system_checks: str | Sequence[str]
+    # Arguments, common to all commands, which aren't defined by the argument parser.
+    base_stealth_options: Tuple[str, ...]
+    # Command-specific options not defined by the argument parser.
+    stealth_options: Tuple[str, ...]
+    suppressed_base_arguments: Set[str]
+
+    stdout: IO[str]
+    stderr: IO[str]
+
+    def __init__(
+        self,
+        stdout: IO[str] | None = None,
+        stderr: IO[str] | None = None,
+        no_color: bool = False,
+        force_color: bool = False,
+    ) -> None: ...
+    def create_parser(
+        self,
+        prog_name: str,
+        subcommand: str | None,
+    ) -> argparse.ArgumentParser: ...
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None: ...
+    def handle(self, *args: Any, **options: Any) -> str | None: ...
+    def execute(self, *args: Any, **options: Any) -> str | None: ...
+    def print_help(self, prog_name: str, subcommand: str | None) -> None: ...
+    def get_version(self) -> str: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/db/models/base.ipy b/python-frontend/typeshed_serializer/resources/custom/django/db/models/base.pyi
similarity index 62%
rename from python-frontend/typeshed_serializer/resources/custom/django/db/models/base.ipy
rename to python-frontend/typeshed_serializer/resources/custom/django/db/models/base.pyi
index 5204be2f4e..5a9176d1c5 100644
--- a/python-frontend/typeshed_serializer/resources/custom/django/db/models/base.ipy
+++ b/python-frontend/typeshed_serializer/resources/custom/django/db/models/base.pyi
@@ -1,3 +1,6 @@
+from django.db.models.manager import Manager
+
 class ModelBase(type): ...
 class Model(metaclass=ModelBase):
+    objects: Manager
     def __init__(self, *args, **kwargs) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/db/models/manager.pyi b/python-frontend/typeshed_serializer/resources/custom/django/db/models/manager.pyi
index 2c94b66a63..aa2eb9cdbc 100644
--- a/python-frontend/typeshed_serializer/resources/custom/django/db/models/manager.pyi
+++ b/python-frontend/typeshed_serializer/resources/custom/django/db/models/manager.pyi
@@ -1,8 +1,54 @@
 from SonarPythonAnalyzerFakeStub import CustomStubBase
 
-
-from typing import Any
+from typing import Any, Iterator
 
 class Manager(CustomStubBase):
-    object: Manager
+
+    # Queryset-returning methods (chainable)
+    def all(self) -> Manager: ...
+    def filter(self, *args, **kwargs) -> Manager: ...
+    def exclude(self, *args, **kwargs) -> Manager: ...
+    def order_by(self, *field_names) -> Manager: ...
+    def reverse(self) -> Manager: ...
+    def distinct(self, *field_names) -> Manager: ...
+    def select_related(self, *fields) -> Manager: ...
+    def prefetch_related(self, *lookups) -> Manager: ...
+    def defer(self, *fields) -> Manager: ...
+    def only(self, *fields) -> Manager: ...
+    def using(self, alias) -> Manager: ...
+    def annotate(self, *args, **kwargs) -> Manager: ...
+    def alias(self, *args, **kwargs) -> Manager: ...
+    def none(self) -> Manager: ...
+    def union(self, *other_qs, all=False) -> Manager: ...
+    def intersection(self, *other_qs) -> Manager: ...
+    def difference(self, *other_qs) -> Manager: ...
+    def select_for_update(self, nowait=False, skip_locked=False, of=(), no_key=False) -> Manager: ...
+    def extra(self, *args, **kwargs) -> Manager: ...
+    def values(self, *fields, **expressions) -> Manager: ...
+    def values_list(self, *fields, flat=False, named=False) -> Manager: ...
+    def dates(self, field_name, kind, order=...) -> Manager: ...
+    def datetimes(self, field_name, kind, order=..., tzinfo=None) -> Manager: ...
+
+    # Methods returning single objects
+    def get(self, *args, **kwargs) -> Any: ...
+    def create(self, **kwargs) -> Any: ...
+    def get_or_create(self, defaults=None, **kwargs) -> tuple: ...
+    def update_or_create(self, defaults=None, create_defaults=None, **kwargs) -> tuple: ...
+    def first(self) -> Any: ...
+    def last(self) -> Any: ...
+    def earliest(self, *fields) -> Any: ...
+    def latest(self, *fields) -> Any: ...
+
+    # Methods returning scalar/collection values
+    def count(self) -> int: ...
+    def exists(self) -> bool: ...
+    def contains(self, obj) -> bool: ...
+    def aggregate(self, *args, **kwargs) -> dict: ...
+    def in_bulk(self, id_list=None, *, field_name=...) -> dict: ...
+    def update(self, **kwargs) -> int: ...
+    def delete(self) -> tuple: ...
+    def bulk_create(self, objs, batch_size=None, **kwargs) -> list: ...
+    def bulk_update(self, objs, fields, batch_size=None) -> int: ...
+    def iterator(self, chunk_size=None) -> Iterator: ...
+    def explain(self, *, format=None, **options) -> str: ...
     def raw(self, *args, **kwargs) -> Any: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/http/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/http/__init__.pyi
index a14a012a6b..4276278cd7 100644
--- a/python-frontend/typeshed_serializer/resources/custom/django/http/__init__.pyi
+++ b/python-frontend/typeshed_serializer/resources/custom/django/http/__init__.pyi
@@ -1,6 +1,10 @@
 import django.http.request as request
 import django.http.response as response
 
+from .request import (
+    HttpRequest as HttpRequest,
+)
+
 from .response import (
     HttpResponse as HttpResponse,
     HttpResponseBadRequest as HttpResponseBadRequest,
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/utils/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/utils/__init__.pyi
index 86ca4ac696..67dc54c097 100644
--- a/python-frontend/typeshed_serializer/resources/custom/django/utils/__init__.pyi
+++ b/python-frontend/typeshed_serializer/resources/custom/django/utils/__init__.pyi
@@ -1 +1,2 @@
 import django.utils.html as html
+import django.utils.deprecation as deprecation
\ No newline at end of file
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/utils/deprecation.pyi b/python-frontend/typeshed_serializer/resources/custom/django/utils/deprecation.pyi
new file mode 100644
index 0000000000..933bce189b
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/utils/deprecation.pyi
@@ -0,0 +1,6 @@
+from typing import Any, Callable
+
+class MiddlewareMixin:
+    get_response: Callable[..., Any]
+    def __init__(self, get_response: Callable[..., Any]) -> None: ...
+    def __call__(self, request: Any) -> Any: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/views/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/views/__init__.pyi
new file mode 100644
index 0000000000..57878ba8ad
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/views/__init__.pyi
@@ -0,0 +1,2 @@
+import django.views.decorators as decorators
+import django.views.generic as generic
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/views/decorators/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/views/decorators/__init__.pyi
new file mode 100644
index 0000000000..174741cc55
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/views/decorators/__init__.pyi
@@ -0,0 +1 @@
+import django.views.decorators.http as http
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/views/decorators/http.pyi b/python-frontend/typeshed_serializer/resources/custom/django/views/decorators/http.pyi
new file mode 100644
index 0000000000..74754e98de
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/views/decorators/http.pyi
@@ -0,0 +1,6 @@
+from typing import Any, Callable, List
+
+def require_http_methods(request_method_list: List[str]) -> Callable[..., Any]: ...
+def require_GET(*args: Any, **kwargs: Any) -> Any: ...
+def require_POST(*args: Any, **kwargs: Any) -> Any: ...
+def require_safe(*args: Any, **kwargs: Any) -> Any: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/views/generic/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/__init__.pyi
new file mode 100644
index 0000000000..4f3d6ed07a
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/__init__.pyi
@@ -0,0 +1,19 @@
+import django.views.generic.base as base
+from django.views.generic.base import RedirectView as RedirectView
+from django.views.generic.base import TemplateView as TemplateView
+from django.views.generic.base import View as View
+from django.views.generic.dates import ArchiveIndexView as ArchiveIndexView
+from django.views.generic.dates import DateDetailView as DateDetailView
+from django.views.generic.dates import DayArchiveView as DayArchiveView
+from django.views.generic.dates import MonthArchiveView as MonthArchiveView
+from django.views.generic.dates import TodayArchiveView as TodayArchiveView
+from django.views.generic.dates import WeekArchiveView as WeekArchiveView
+from django.views.generic.dates import YearArchiveView as YearArchiveView
+from django.views.generic.detail import DetailView as DetailView
+from django.views.generic.edit import CreateView as CreateView
+from django.views.generic.edit import DeleteView as DeleteView
+from django.views.generic.edit import FormView as FormView
+from django.views.generic.edit import UpdateView as UpdateView
+from django.views.generic.list import ListView as ListView
+
+class GenericViewError(Exception): ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/views/generic/base.pyi b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/base.pyi
new file mode 100644
index 0000000000..319e9169b6
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/base.pyi
@@ -0,0 +1,59 @@
+from typing import Any, Callable, Dict, List, Optional, Type
+
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse
+
+class ContextMixin:
+    extra_context: Optional[Dict[str, Any]]
+    def get_context_data(self, **kwargs: Any) -> Dict[str, Any]: ...
+
+class View:
+    http_method_names: List[str]
+    request: HttpRequest
+    args: tuple
+    kwargs: dict
+    def setup(self, request: HttpRequest, *args: Any, **kwargs: Any) -> None: ...
+    def dispatch(
+        self, request: HttpRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...
+    def http_method_not_allowed(
+        self, request: HttpRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...
+    def options(
+        self, request: HttpRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...
+    @classmethod
+    def as_view(cls, **initkwargs: Any) -> Callable[..., HttpResponse]: ...
+
+class TemplateResponseMixin:
+    template_name: Optional[str]
+    template_engine: Optional[str]
+    response_class: Type[HttpResponse]
+    content_type: Optional[str]
+    def render_to_response(
+        self, context: Dict[str, Any], **response_kwargs: Any
+    ) -> HttpResponse: ...
+    def get_template_names(self) -> List[str]: ...
+
+class TemplateView(TemplateResponseMixin, ContextMixin, View):
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+
+class RedirectView(View):
+    permanent: bool
+    url: Optional[str]
+    pattern_name: Optional[str]
+    query_string: bool
+    def get_redirect_url(self, *args: Any, **kwargs: Any) -> Optional[str]: ...
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def head(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def options(
+        self, request: HttpRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...
+    def delete(
+        self, request: HttpRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...
+    def put(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def patch(
+        self, request: HttpRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/views/generic/dates.pyi b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/dates.pyi
new file mode 100644
index 0000000000..af3a61d06c
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/dates.pyi
@@ -0,0 +1,115 @@
+import datetime
+from typing import Any, Dict, List, Optional, Tuple, Type
+
+from django.core.paginator import Paginator
+from django.db.models import Model
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse
+from django.views.generic.base import View
+from django.views.generic.detail import (
+    BaseDetailView,
+    SingleObjectTemplateResponseMixin,
+)
+from django.views.generic.list import (
+    MultipleObjectMixin,
+    MultipleObjectTemplateResponseMixin,
+)
+
+class YearMixin:
+    year_format: str
+    year: Optional[str]
+    def get_year_format(self) -> str: ...
+    def get_year(self) -> str: ...
+    def get_next_year(self, date: datetime.date) -> Optional[datetime.date]: ...
+    def get_previous_year(self, date: datetime.date) -> Optional[datetime.date]: ...
+
+class MonthMixin:
+    month_format: str
+    month: Optional[str]
+    def get_month_format(self) -> str: ...
+    def get_month(self) -> str: ...
+    def get_next_month(self, date: datetime.date) -> Optional[datetime.date]: ...
+    def get_previous_month(self, date: datetime.date) -> Optional[datetime.date]: ...
+
+class DayMixin:
+    day_format: str
+    day: Optional[str]
+    def get_day_format(self) -> str: ...
+    def get_day(self) -> str: ...
+    def get_next_day(self, date: datetime.date) -> Optional[datetime.date]: ...
+    def get_previous_day(self, date: datetime.date) -> Optional[datetime.date]: ...
+
+class WeekMixin:
+    week_format: str
+    week: Optional[str]
+    def get_week_format(self) -> str: ...
+    def get_week(self) -> str: ...
+    def get_next_week(self, date: datetime.date) -> Optional[datetime.date]: ...
+    def get_previous_week(self, date: datetime.date) -> Optional[datetime.date]: ...
+
+class DateMixin:
+    date_field: Optional[str]
+    allow_future: bool
+    uses_datetime_field: bool
+    def get_date_field(self) -> str: ...
+    def get_allow_future(self) -> bool: ...
+
+class BaseDateListView(MultipleObjectMixin, DateMixin, View):
+    allow_empty: bool
+    date_list_period: str
+    date_list: Any
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def get_dated_items(self) -> Tuple[Any, Any, Dict[str, Any]]: ...
+    def get_ordering(self) -> Optional[Any]: ...
+    def get_dated_queryset(self, **lookup: Any) -> Any: ...
+    def get_date_list_period(self) -> str: ...
+    def get_date_list(
+        self, queryset: Any, date_type: Optional[str] = ..., ordering: str = ...
+    ) -> Any: ...
+
+class BaseArchiveIndexView(BaseDateListView):
+    context_object_name: str
+    def get_dated_items(self) -> Tuple[Any, Any, Dict[str, Any]]: ...
+
+class ArchiveIndexView(MultipleObjectTemplateResponseMixin, BaseArchiveIndexView):
+    template_name_suffix: str
+
+class BaseYearArchiveView(YearMixin, BaseDateListView):
+    date_list_period: str
+    make_object_list: bool
+    def get_dated_items(self) -> Tuple[Any, Any, Dict[str, Any]]: ...
+    def get_make_object_list(self) -> bool: ...
+
+class YearArchiveView(MultipleObjectTemplateResponseMixin, BaseYearArchiveView):
+    template_name_suffix: str
+
+class BaseMonthArchiveView(YearMixin, MonthMixin, BaseDateListView):
+    date_list_period: str
+    def get_dated_items(self) -> Tuple[Any, Any, Dict[str, Any]]: ...
+
+class MonthArchiveView(MultipleObjectTemplateResponseMixin, BaseMonthArchiveView):
+    template_name_suffix: str
+
+class BaseWeekArchiveView(YearMixin, WeekMixin, BaseDateListView):
+    def get_dated_items(self) -> Tuple[Any, Any, Dict[str, Any]]: ...
+
+class WeekArchiveView(MultipleObjectTemplateResponseMixin, BaseWeekArchiveView):
+    template_name_suffix: str
+
+class BaseDayArchiveView(YearMixin, MonthMixin, DayMixin, BaseDateListView):
+    def get_dated_items(self) -> Tuple[Any, Any, Dict[str, Any]]: ...
+
+class DayArchiveView(MultipleObjectTemplateResponseMixin, BaseDayArchiveView):
+    template_name_suffix: str
+
+class BaseTodayArchiveView(BaseDayArchiveView):
+    def get_dated_items(self) -> Tuple[Any, Any, Dict[str, Any]]: ...
+
+class TodayArchiveView(MultipleObjectTemplateResponseMixin, BaseTodayArchiveView):
+    template_name_suffix: str
+
+class BaseDateDetailView(YearMixin, MonthMixin, DayMixin, DateMixin, BaseDetailView):
+    def get_object(self, queryset: Optional[Any] = ...) -> Any: ...
+
+class DateDetailView(SingleObjectTemplateResponseMixin, BaseDateDetailView):
+    template_name_suffix: str
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/views/generic/detail.pyi b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/detail.pyi
new file mode 100644
index 0000000000..5230a8e573
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/detail.pyi
@@ -0,0 +1,32 @@
+from typing import Any, Dict, List, Optional, Type
+
+from django.db.models import Model
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+
+class SingleObjectMixin(ContextMixin):
+    model: Optional[Type[Model]]
+    queryset: Optional[Any]
+    slug_field: str
+    context_object_name: Optional[str]
+    slug_url_kwarg: str
+    pk_url_kwarg: str
+    query_pk_and_slug: bool
+    object: Any
+    def get_object(self, queryset: Optional[Any] = ...) -> Any: ...
+    def get_queryset(self) -> Any: ...
+    def get_slug_field(self) -> str: ...
+    def get_context_object_name(self, obj: Any) -> Optional[str]: ...
+    def get_context_data(self, **kwargs: Any) -> Dict[str, Any]: ...
+
+class BaseDetailView(SingleObjectMixin, View):
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+
+class SingleObjectTemplateResponseMixin(TemplateResponseMixin):
+    template_name_field: Optional[str]
+    template_name_suffix: str
+    def get_template_names(self) -> List[str]: ...
+
+class DetailView(SingleObjectTemplateResponseMixin, BaseDetailView):
+    pass
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/views/generic/edit.pyi b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/edit.pyi
new file mode 100644
index 0000000000..97f3742fa0
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/edit.pyi
@@ -0,0 +1,74 @@
+from typing import Any, Dict, List, Optional, Type
+
+from django.forms import Form
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+from django.views.generic.detail import (
+    BaseDetailView,
+    SingleObjectMixin,
+    SingleObjectTemplateResponseMixin,
+)
+
+class FormMixin(ContextMixin):
+    initial: Dict[str, Any]
+    form_class: Optional[Type[Form]]
+    success_url: Optional[str]
+    prefix: Optional[str]
+    def get_initial(self) -> Dict[str, Any]: ...
+    def get_prefix(self) -> Optional[str]: ...
+    def get_form_class(self) -> Type[Form]: ...
+    def get_form(self, form_class: Optional[Type[Form]] = ...) -> Form: ...
+    def get_form_kwargs(self) -> Dict[str, Any]: ...
+    def get_success_url(self) -> str: ...
+    def form_valid(self, form: Form) -> HttpResponse: ...
+    def form_invalid(self, form: Form) -> HttpResponse: ...
+    def get_context_data(self, **kwargs: Any) -> Dict[str, Any]: ...
+
+class ModelFormMixin(FormMixin, SingleObjectMixin):
+    fields: Optional[Any]
+    def get_form_class(self) -> Type[Form]: ...
+    def get_form_kwargs(self) -> Dict[str, Any]: ...
+    def get_success_url(self) -> str: ...
+    def form_valid(self, form: Form) -> HttpResponse: ...
+
+class ProcessFormView(View):
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def put(self, *args: Any, **kwargs: Any) -> HttpResponse: ...
+
+class BaseFormView(FormMixin, ProcessFormView):
+    pass
+
+class FormView(TemplateResponseMixin, BaseFormView):
+    pass
+
+class BaseCreateView(ModelFormMixin, ProcessFormView):
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+
+class CreateView(SingleObjectTemplateResponseMixin, BaseCreateView):
+    template_name_suffix: str
+
+class BaseUpdateView(ModelFormMixin, ProcessFormView):
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+
+class UpdateView(SingleObjectTemplateResponseMixin, BaseUpdateView):
+    template_name_suffix: str
+
+class DeletionMixin:
+    success_url: Optional[str]
+    def delete(
+        self, request: HttpRequest, *args: Any, **kwargs: Any
+    ) -> HttpResponse: ...
+    def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def get_success_url(self) -> str: ...
+
+class BaseDeleteView(DeletionMixin, FormMixin, BaseDetailView):
+    form_class: Type[Form]
+    def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+    def form_valid(self, form: Form) -> HttpResponse: ...
+
+class DeleteView(SingleObjectTemplateResponseMixin, BaseDeleteView):
+    template_name_suffix: str
diff --git a/python-frontend/typeshed_serializer/resources/custom/django/views/generic/list.pyi b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/list.pyi
new file mode 100644
index 0000000000..add51a7342
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/django/views/generic/list.pyi
@@ -0,0 +1,49 @@
+from typing import Any, Dict, List, Optional, Tuple, Type
+
+from django.core.paginator import Paginator
+from django.db.models import Model
+from django.http.request import HttpRequest
+from django.http.response import HttpResponse
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+
+class MultipleObjectMixin(ContextMixin):
+    allow_empty: bool
+    queryset: Optional[Any]
+    model: Optional[Type[Model]]
+    paginate_by: Optional[int]
+    paginate_orphans: int
+    context_object_name: Optional[str]
+    paginator_class: Type[Paginator]
+    page_kwarg: str
+    ordering: Optional[Any]
+    object_list: Any
+    def get_queryset(self) -> Any: ...
+    def get_ordering(self) -> Optional[Any]: ...
+    def paginate_queryset(
+        self, queryset: Any, page_size: int
+    ) -> Tuple[Paginator, Any, Any, bool]: ...
+    def get_paginate_by(self, queryset: Any) -> Optional[int]: ...
+    def get_paginator(
+        self,
+        queryset: Any,
+        per_page: int,
+        orphans: int = ...,
+        allow_empty_first_page: bool = ...,
+        **kwargs: Any,
+    ) -> Paginator: ...
+    def get_paginate_orphans(self) -> int: ...
+    def get_allow_empty(self) -> bool: ...
+    def get_context_object_name(self, object_list: Any) -> Optional[str]: ...
+    def get_context_data(
+        self, *, object_list: Optional[Any] = ..., **kwargs: Any
+    ) -> Dict[str, Any]: ...
+
+class BaseListView(MultipleObjectMixin, View):
+    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ...
+
+class MultipleObjectTemplateResponseMixin(TemplateResponseMixin):
+    template_name_suffix: str
+    def get_template_names(self) -> List[str]: ...
+
+class ListView(MultipleObjectTemplateResponseMixin, BaseListView):
+    pass
diff --git a/python-frontend/typeshed_serializer/resources/custom/httpx/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/httpx/__init__.pyi
new file mode 100644
index 0000000000..99ff054d6b
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/httpx/__init__.pyi
@@ -0,0 +1,8 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+from typing import Any, Dict, List, Callable
+
+class AsyncClient(CustomStubBase):
+    def __init__(self, *, event_hooks: Dict[str, List[Callable[..., Any]]] = ..., **kwargs: Any) -> None: ...
+
+class Client(CustomStubBase):
+    def __init__(self, *, event_hooks: Dict[str, List[Callable[..., Any]]] = ..., **kwargs: Any) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/marimo/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/marimo/__init__.pyi
new file mode 100644
index 0000000000..c1e9c49231
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/marimo/__init__.pyi
@@ -0,0 +1,9 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+from typing import Any
+
+class App(CustomStubBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def cell(self, *args: Any, **kwargs: Any) -> Any: ...
+    def function(self, *args: Any, **kwargs: Any) -> Any: ...
+
+def sql(query: str, **kwargs: Any) -> Any: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pg/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/pg/__init__.pyi
new file mode 100644
index 0000000000..4ab0dbfd80
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pg/__init__.pyi
@@ -0,0 +1,13 @@
+from pg.connection import Connection
+from pg.db import DB
+from typing import Optional
+
+def connect(
+    dbname: Optional[str] = None,
+    host: Optional[str] = None,
+    port: int = -1,
+    opt: Optional[str] = None,
+    user: Optional[str] = None,
+    passwd: Optional[str] = None,
+    nowait: bool = False,
+) -> Connection: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pg/connection.pyi b/python-frontend/typeshed_serializer/resources/custom/pg/connection.pyi
new file mode 100644
index 0000000000..e7a0bd3ff9
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pg/connection.pyi
@@ -0,0 +1,16 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+from typing import Optional
+
+class Connection(CustomStubBase):
+    def __init__(
+        self,
+        dbname: Optional[str] = None,
+        host: Optional[str] = None,
+        port: int = -1,
+        opt: Optional[str] = None,
+        user: Optional[str] = None,
+        passwd: Optional[str] = None,
+        nowait: bool = False,
+    ) -> None: ...
+    def query(self, command: str, *args) -> None: ...
+    def close(self) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pg/db.pyi b/python-frontend/typeshed_serializer/resources/custom/pg/db.pyi
new file mode 100644
index 0000000000..1118c66cb8
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pg/db.pyi
@@ -0,0 +1,16 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+from typing import Optional
+
+class DB(CustomStubBase):
+    def __init__(
+        self,
+        dbname: Optional[str] = None,
+        host: Optional[str] = None,
+        port: int = -1,
+        opt: Optional[str] = None,
+        user: Optional[str] = None,
+        passwd: Optional[str] = None,
+        nowait: bool = False,
+    ) -> None: ...
+    def query(self, command: str, *args) -> None: ...
+    def close(self) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pydantic/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/pydantic/__init__.pyi
new file mode 100644
index 0000000000..e8575a8802
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pydantic/__init__.pyi
@@ -0,0 +1,5 @@
+from pydantic.config import ConfigDict
+from pydantic.fields import Field, FieldInfo, PrivateAttr
+from pydantic.main import BaseModel
+from pydantic.types import *
+from pydantic.networks import *
diff --git a/python-frontend/typeshed_serializer/resources/custom/pydantic/config.pyi b/python-frontend/typeshed_serializer/resources/custom/pydantic/config.pyi
new file mode 100644
index 0000000000..0928de3636
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pydantic/config.pyi
@@ -0,0 +1,4 @@
+from typing import Any
+
+class ConfigDict:
+    def __init__(self, **kwargs: Any) -> None: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pydantic/fields.pyi b/python-frontend/typeshed_serializer/resources/custom/pydantic/fields.pyi
new file mode 100644
index 0000000000..e05fc5a556
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pydantic/fields.pyi
@@ -0,0 +1,8 @@
+from typing import Any
+
+class FieldInfo: ...
+
+class PrivateAttr:
+    def __init__(self, default: Any = ..., **kwargs: Any) -> None: ...
+
+def Field(default: Any = ..., **kwargs: Any) -> Any: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pydantic/functional_validators.pyi b/python-frontend/typeshed_serializer/resources/custom/pydantic/functional_validators.pyi
new file mode 100644
index 0000000000..ebd7e168a0
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pydantic/functional_validators.pyi
@@ -0,0 +1,34 @@
+from typing import Any, Callable, Literal
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+
+FieldValidatorModes = Literal['before', 'after', 'wrap', 'plain']
+
+def field_validator(
+    field: str,
+    /,
+    *fields: str,
+    mode: FieldValidatorModes = ...,
+    check_fields: bool | None = ...,
+    json_schema_input_type: Any = ...,
+) -> Callable[..., Any]: ...
+
+def model_validator(
+    *,
+    mode: Literal['wrap', 'before', 'after'],
+) -> Any: ...
+
+class AfterValidator(CustomStubBase):
+    def __init__(self, func: Callable[..., Any]) -> None: ...
+
+class BeforeValidator(CustomStubBase):
+    def __init__(self, func: Callable[..., Any], json_schema_input_type: Any = ...) -> None: ...
+
+class PlainValidator(CustomStubBase):
+    def __init__(self, func: Callable[..., Any], json_schema_input_type: Any = ...) -> None: ...
+
+class WrapValidator(CustomStubBase):
+    def __init__(self, func: Callable[..., Any], json_schema_input_type: Any = ...) -> None: ...
+
+class InstanceOf(CustomStubBase): ...
+
+class SkipValidation(CustomStubBase): ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pydantic/main.pyi b/python-frontend/typeshed_serializer/resources/custom/pydantic/main.pyi
new file mode 100644
index 0000000000..5f61c2efd5
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pydantic/main.pyi
@@ -0,0 +1 @@
+class BaseModel: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pydantic/networks.pyi b/python-frontend/typeshed_serializer/resources/custom/pydantic/networks.pyi
new file mode 100644
index 0000000000..d151eec3ce
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pydantic/networks.pyi
@@ -0,0 +1,54 @@
+# URL types (FQN: pydantic.networks.*)
+# All URL classes share the same interface — they wrap pydantic_core.Url internally.
+class AnyUrl:
+    scheme: str
+    host: str
+    path: str
+    port: int
+    query: str | None
+    fragment: str | None
+    username: str | None
+    password: str | None
+    def unicode_string(self) -> str: ...
+    def unicode_host(self) -> str: ...
+    def query_params(self) -> list: ...
+    def encoded_string(self) -> str: ...
+
+class AnyHttpUrl(AnyUrl): ...
+class HttpUrl(AnyUrl): ...
+class FileUrl(AnyUrl): ...
+class AnyWebsocketUrl(AnyUrl): ...
+class WebsocketUrl(AnyUrl): ...
+class FtpUrl(AnyUrl): ...
+class AmqpDsn(AnyUrl): ...
+class CockroachDsn(AnyUrl): ...
+class KafkaDsn(AnyUrl): ...
+class RedisDsn(AnyUrl): ...
+class PostgresDsn(AnyUrl): ...
+class MongoDsn(AnyUrl): ...
+
+# pydantic.networks.Url — identical to pydantic_core.Url at runtime (same object in pydantic v2).
+# Defined here as a class so `from pydantic.networks import Url` resolves to FQN pydantic.networks.Url
+# (cross-stub re-exports are not followed by the type engine).
+# TODO: consolidate to pydantic_core.Url on the security side (FastApiSource.java).
+class Url:
+    scheme: str
+    host: str
+    path: str
+    port: int
+    query: str | None
+    fragment: str | None
+    username: str | None
+    password: str | None
+    def unicode_string(self) -> str: ...
+    def unicode_host(self) -> str: ...
+    def query_params(self) -> list: ...
+
+# Network address types (FQN: pydantic.networks.*)
+class IPvAnyAddress: ...
+class IPvAnyInterface: ...
+class IPvAnyNetwork: ...
+
+# Email / name types (FQN: pydantic.networks.*)
+class EmailStr(str): ...
+class NameEmail: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pydantic/types.pyi b/python-frontend/typeshed_serializer/resources/custom/pydantic/types.pyi
new file mode 100644
index 0000000000..a286fe0435
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pydantic/types.pyi
@@ -0,0 +1,79 @@
+from typing import Any
+from decimal import Decimal
+from datetime import date, datetime
+from pathlib import Path
+from uuid import UUID
+
+# Real classes defined in pydantic.types (FQN: pydantic.types.*)
+class SecretStr:
+    def __init__(self, secret_value: str) -> None: ...
+    def get_secret_value(self) -> str: ...
+
+class ByteSize(int): ...
+class Json: ...
+class ImportString: ...
+class StringConstraints: ...
+class PaymentCardNumber: ...
+class PastDate(date): ...
+class FutureDate(date): ...
+class PastDatetime(datetime): ...
+class FutureDatetime(datetime): ...
+class AwareDatetime(datetime): ...
+class NaiveDatetime(datetime): ...
+
+# Constrained type factories (FQN: pydantic.types.*)
+class conint(int):
+    def __init__(self, *, strict: bool = ..., gt: int = ..., ge: int = ..., lt: int = ..., le: int = ..., multiple_of: int = ...) -> None: ...
+
+class conlist(list):
+    def __init__(self, item_type: Any = ..., *, min_length: int = ..., max_length: int = ...) -> None: ...
+
+class conset(set):
+    def __init__(self, item_type: Any = ..., *, min_length: int = ..., max_length: int = ...) -> None: ...
+
+class confrozenset(frozenset):
+    def __init__(self, item_type: Any = ..., *, min_length: int = ..., max_length: int = ...) -> None: ...
+
+class conbytes(bytes):
+    def __init__(self, *, strict: bool = ..., min_length: int = ..., max_length: int = ...) -> None: ...
+
+class constr(str):
+    def __init__(self, *, strip_whitespace: bool = ..., to_upper: bool = ..., to_lower: bool = ..., strict: bool = ..., min_length: int = ..., max_length: int = ..., pattern: str = ..., ascii_only: bool = ...) -> None: ...
+
+class confloat(float):
+    def __init__(self, *, strict: bool = ..., gt: float = ..., ge: float = ..., lt: float = ..., le: float = ..., multiple_of: float = ..., allow_inf_nan: bool = ...) -> None: ...
+
+class condecimal(Decimal):
+    def __init__(self, *, strict: bool = ..., gt: Any = ..., ge: Any = ..., lt: Any = ..., le: Any = ..., multiple_of: Any = ..., max_digits: int = ..., decimal_places: int = ..., allow_inf_nan: bool = ...) -> None: ...
+
+class condate(date):
+    def __init__(self, *, strict: bool = ..., gt: date = ..., ge: date = ..., lt: date = ..., le: date = ...) -> None: ...
+
+# Annotated aliases — no real class, defined in pydantic.types as Annotated[, ...]
+# Best FQN is pydantic.types.* (where they are defined in pydantic source)
+class StrictStr(str): ...
+
+class PositiveInt(int): ...
+class NegativeInt(int): ...
+class NonNegativeInt(int): ...
+class NonPositiveInt(int): ...
+
+class PositiveFloat(float): ...
+class NegativeFloat(float): ...
+class NonNegativeFloat(float): ...
+class NonPositiveFloat(float): ...
+class FiniteFloat(float): ...
+
+class FilePath(Path): ...
+class DirectoryPath(Path): ...
+class NewPath(Path): ...
+
+class Base64Bytes(bytes): ...
+class Base64UrlBytes(bytes): ...
+class Base64Str(str): ...
+class Base64UrlStr(str): ...
+
+class UUID1(UUID): ...
+class UUID3(UUID): ...
+class UUID4(UUID): ...
+class UUID5(UUID): ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pydantic_core/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/pydantic_core/__init__.pyi
new file mode 100644
index 0000000000..c743224cc2
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pydantic_core/__init__.pyi
@@ -0,0 +1,56 @@
+from typing import Any, Callable, Optional
+
+# URL type (FQN: pydantic_core._pydantic_core.Url, exposed as pydantic_core.Url)
+# Identical interface to pydantic.networks.AnyUrl/_BaseUrl — same object in pydantic v2.
+class Url:
+    scheme: str
+    host: str
+    path: str
+    port: int
+    query: Optional[str]
+    fragment: Optional[str]
+    username: Optional[str]
+    password: Optional[str]
+    def unicode_string(self) -> str: ...
+    def unicode_host(self) -> str: ...
+    def query_params(self) -> list: ...
+
+def to_json(
+    value: Any,
+    *,
+    indent: Optional[int] = ...,
+    ensure_ascii: bool = ...,
+    include: Any = ...,
+    exclude: Any = ...,
+    by_alias: bool = ...,
+    exclude_none: bool = ...,
+    round_trip: bool = ...,
+    timedelta_mode: str = ...,
+    temporal_mode: str = ...,
+    bytes_mode: str = ...,
+    inf_nan_mode: str = ...,
+    serialize_unknown: bool = ...,
+    fallback: Optional[Callable[..., Any]] = ...,
+    serialize_as_any: bool = ...,
+    polymorphic_serialization: Optional[bool] = ...,
+    context: Optional[Any] = ...,
+) -> bytes: ...
+
+def to_jsonable_python(
+    value: Any,
+    *,
+    include: Any = ...,
+    exclude: Any = ...,
+    by_alias: bool = ...,
+    exclude_none: bool = ...,
+    round_trip: bool = ...,
+    timedelta_mode: str = ...,
+    temporal_mode: str = ...,
+    bytes_mode: str = ...,
+    inf_nan_mode: str = ...,
+    serialize_unknown: bool = ...,
+    fallback: Optional[Callable[..., Any]] = ...,
+    serialize_as_any: bool = ...,
+    polymorphic_serialization: Optional[bool] = ...,
+    context: Optional[Any] = ...,
+) -> Any: ...
diff --git a/python-frontend/typeshed_serializer/resources/custom/pytest/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/pytest/__init__.pyi
new file mode 100644
index 0000000000..b805881894
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pytest/__init__.pyi
@@ -0,0 +1,13 @@
+from SonarPythonAnalyzerFakeStub import CustomStubBase
+from _pytest.fixtures import FixtureRequest
+
+class ApproxScalar(CustomStubBase): ...
+
+def approx(expected: object = ..., *args: object, **kwargs: object) -> ApproxScalar: ...
+def fixture(*args: object, **kwargs: object): ...
+def yield_fixture(*args: object, **kwargs: object): ...
+def fail(*args: object, **kwargs: object): ...
+def raises(*args: object, **kwargs: object): ...
+def warns(*args: object, **kwargs: object): ...
+
+import pytest.mark as mark
diff --git a/python-frontend/typeshed_serializer/resources/custom/pytest/mark/__init__.pyi b/python-frontend/typeshed_serializer/resources/custom/pytest/mark/__init__.pyi
new file mode 100644
index 0000000000..e693fbc342
--- /dev/null
+++ b/python-frontend/typeshed_serializer/resources/custom/pytest/mark/__init__.pyi
@@ -0,0 +1,13 @@
+from typing import Any, Callable, Sequence, TypeVar, Union
+
+_T = TypeVar("_T")
+
+def xfail(*args: Any, reason: str = ..., **kwargs: Any) -> Callable[[_T], _T]: ...
+def skip(*args: Any, reason: str = ..., **kwargs: Any) -> Callable[[_T], _T]: ...
+def usefixtures(*fixtures: str) -> Callable[[_T], _T]: ...
+def parametrize(
+    argnames: Union[str, Sequence[str]],
+    argvalues: object,
+    *args: Any,
+    **kwargs: Any,
+) -> Callable[[_T], _T]: ...
diff --git a/python-frontend/typeshed_serializer/runners/__init__.py b/python-frontend/typeshed_serializer/runners/__init__.py
index 2a765941b7..2739b9a3ec 100644
--- a/python-frontend/typeshed_serializer/runners/__init__.py
+++ b/python-frontend/typeshed_serializer/runners/__init__.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/runners/tox_runner.py b/python-frontend/typeshed_serializer/runners/tox_runner.py
index 4fd46c6de6..f6b17f1954 100644
--- a/python-frontend/typeshed_serializer/runners/tox_runner.py
+++ b/python-frontend/typeshed_serializer/runners/tox_runner.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -216,9 +216,9 @@ def detect_required_serializations(fail_fast=False) -> List[str]:
         binary_changed = compute_and_compare_checksums("BINARY", folder_name, binary_files, read_file, previous_binary_checksum)
 
         if ressources_changed or binary_changed:
-            # Check for binary inconsistency (binary changed but source didn't)
-            if binary_changed and not ressources_changed and fail_fast:
-                raise RuntimeError('INCONSISTENT RESOURCE FOLDER BINARY CHECKSUMS')
+            # In CI fail-fast mode, the committed checksums must already match the tracked tree.
+            if fail_fast:
+                raise RuntimeError('INCONSISTENT RESOURCE FOLDER CHECKSUMS')
             ressources_that_needs_serialization.append(folder_config['serializer'])
 
     return ressources_that_needs_serialization
diff --git a/python-frontend/typeshed_serializer/serializer/__init__.py b/python-frontend/typeshed_serializer/serializer/__init__.py
index 2a765941b7..2739b9a3ec 100644
--- a/python-frontend/typeshed_serializer/serializer/__init__.py
+++ b/python-frontend/typeshed_serializer/serializer/__init__.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/serializer/serializers.py b/python-frontend/typeshed_serializer/serializer/serializers.py
index 022cfe0018..5c2c1f3a07 100644
--- a/python-frontend/typeshed_serializer/serializer/serializers.py
+++ b/python-frontend/typeshed_serializer/serializer/serializers.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/serializer/symbols.py b/python-frontend/typeshed_serializer/serializer/symbols.py
index c423685eff..db583ada46 100644
--- a/python-frontend/typeshed_serializer/serializer/symbols.py
+++ b/python-frontend/typeshed_serializer/serializer/symbols.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/serializer/symbols_merger.py b/python-frontend/typeshed_serializer/serializer/symbols_merger.py
index 8d6898183c..2e39fccab8 100644
--- a/python-frontend/typeshed_serializer/serializer/symbols_merger.py
+++ b/python-frontend/typeshed_serializer/serializer/symbols_merger.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/serializer/typeshed_serializer.py b/python-frontend/typeshed_serializer/serializer/typeshed_serializer.py
index 40b2d224cf..5f2a12b955 100644
--- a/python-frontend/typeshed_serializer/serializer/typeshed_serializer.py
+++ b/python-frontend/typeshed_serializer/serializer/typeshed_serializer.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/serializer_sources.checksum b/python-frontend/typeshed_serializer/serializer_sources.checksum
index 3a57d67402..ed233a9030 100644
--- a/python-frontend/typeshed_serializer/serializer_sources.checksum
+++ b/python-frontend/typeshed_serializer/serializer_sources.checksum
@@ -1 +1 @@
-75ec98e58a7ae0ccd94f569d49e43f9034a6d2744ade0ba7565718a139edf33b
\ No newline at end of file
+d6efb772028a4dbf9e8c5fd2ef498d286a56750dee3c84231fefd0789a7c50bd
\ No newline at end of file
diff --git a/python-frontend/typeshed_serializer/tests/__init__.py b/python-frontend/typeshed_serializer/tests/__init__.py
index 2a765941b7..2739b9a3ec 100644
--- a/python-frontend/typeshed_serializer/tests/__init__.py
+++ b/python-frontend/typeshed_serializer/tests/__init__.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/tests/conftest.py b/python-frontend/typeshed_serializer/tests/conftest.py
index eb8636b2ad..eeaddb6ada 100644
--- a/python-frontend/typeshed_serializer/tests/conftest.py
+++ b/python-frontend/typeshed_serializer/tests/conftest.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/tests/runners/__init__.py b/python-frontend/typeshed_serializer/tests/runners/__init__.py
index 2a765941b7..2739b9a3ec 100644
--- a/python-frontend/typeshed_serializer/tests/runners/__init__.py
+++ b/python-frontend/typeshed_serializer/tests/runners/__init__.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/tests/runners/test_tox_runner.py b/python-frontend/typeshed_serializer/tests/runners/test_tox_runner.py
index f9d3c6ee10..a98f6a4609 100644
--- a/python-frontend/typeshed_serializer/tests/runners/test_tox_runner.py
+++ b/python-frontend/typeshed_serializer/tests/runners/test_tox_runner.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -617,7 +617,91 @@ def test_detect_required_serializations_fail_fast_binary_inconsistent(self):
                 tox_runner.detect_required_serializations(fail_fast=True)
 
             self.assertEqual(
-                str(error.exception), "INCONSISTENT RESOURCE FOLDER BINARY CHECKSUMS"
+                str(error.exception), "INCONSISTENT RESOURCE FOLDER CHECKSUMS"
+            )
+
+    def test_detect_required_serializations_fail_fast_source_inconsistent(self):
+        mock_resources_folders = {
+            "custom": {
+                "serializer": "custom",
+                "source_path": "custom",
+            }
+        }
+
+        with (
+            mock.patch(
+                f"{self.MODULE_NAME}.RESOURCES_FOLDERS",
+                mock_resources_folders,
+            ),
+            mock.patch(
+                f"{self.MODULE_NAME}.fetch_resources_subfolder_files"
+            ) as mock_resources_files,
+            mock.patch(self.COMPUTE_CHECKSUM_FUNCTION) as mocked_checksum,
+            mock.patch(
+                f"{self.MODULE_NAME}.fetch_binary_files_for_folder"
+            ) as mock_binary_files,
+            mock.patch(
+                f"{self.MODULE_NAME}.read_previous_folder_checksum"
+            ) as mock_read_checksum,
+        ):
+            mock_resources_files.return_value = [os.path.join("custom", "test.pyi")]
+            mock_binary_files.return_value = [os.path.join("custom_protobuf", "test.protobuf")]
+            mocked_checksum.side_effect = [
+                "456",
+                "123",
+            ]
+            mock_read_checksum.return_value = (
+                "999",
+                "123",
+            )
+
+            with self.assertRaises(RuntimeError) as error:
+                tox_runner.detect_required_serializations(fail_fast=True)
+
+            self.assertEqual(
+                str(error.exception), "INCONSISTENT RESOURCE FOLDER CHECKSUMS"
+            )
+
+    def test_detect_required_serializations_fail_fast_source_and_binary_inconsistent(self):
+        mock_resources_folders = {
+            "custom": {
+                "serializer": "custom",
+                "source_path": "custom",
+            }
+        }
+
+        with (
+            mock.patch(
+                f"{self.MODULE_NAME}.RESOURCES_FOLDERS",
+                mock_resources_folders,
+            ),
+            mock.patch(
+                f"{self.MODULE_NAME}.fetch_resources_subfolder_files"
+            ) as mock_resources_files,
+            mock.patch(self.COMPUTE_CHECKSUM_FUNCTION) as mocked_checksum,
+            mock.patch(
+                f"{self.MODULE_NAME}.fetch_binary_files_for_folder"
+            ) as mock_binary_files,
+            mock.patch(
+                f"{self.MODULE_NAME}.read_previous_folder_checksum"
+            ) as mock_read_checksum,
+        ):
+            mock_resources_files.return_value = [os.path.join("custom", "test.pyi")]
+            mock_binary_files.return_value = [os.path.join("custom_protobuf", "test.protobuf")]
+            mocked_checksum.side_effect = [
+                "456",
+                "789",
+            ]
+            mock_read_checksum.return_value = (
+                "999",
+                "123",
+            )
+
+            with self.assertRaises(RuntimeError) as error:
+                tox_runner.detect_required_serializations(fail_fast=True)
+
+            self.assertEqual(
+                str(error.exception), "INCONSISTENT RESOURCE FOLDER CHECKSUMS"
             )
 
     def test_detect_required_serializations_no_fail_fast_binary_inconsistent(self):
@@ -665,8 +749,46 @@ def test_detect_required_serializations_no_fail_fast_binary_inconsistent(self):
             result = tox_runner.detect_required_serializations(fail_fast=False)
             self.assertEqual(result, ["custom"])
 
-    def test_main_fail_fast_resource_folder_binary_inconsistent(self):
-        # Test main function fail-fast when resource folder has binary inconsistency
+    def test_detect_required_serializations_no_fail_fast_source_and_binary_inconsistent(self):
+        mock_resources_folders = {
+            "custom": {
+                "serializer": "custom",
+                "source_path": "custom",
+            }
+        }
+
+        with (
+            mock.patch(
+                f"{self.MODULE_NAME}.RESOURCES_FOLDERS",
+                mock_resources_folders,
+            ),
+            mock.patch(
+                f"{self.MODULE_NAME}.fetch_resources_subfolder_files"
+            ) as mock_resources_files,
+            mock.patch(self.COMPUTE_CHECKSUM_FUNCTION) as mocked_checksum,
+            mock.patch(
+                f"{self.MODULE_NAME}.fetch_binary_files_for_folder"
+            ) as mock_binary_files,
+            mock.patch(
+                f"{self.MODULE_NAME}.read_previous_folder_checksum"
+            ) as mock_read_checksum,
+        ):
+            mock_resources_files.return_value = [os.path.join("custom", "test.pyi")]
+            mock_binary_files.return_value = [os.path.join("custom_protobuf", "test.protobuf")]
+            mocked_checksum.side_effect = [
+                "456",
+                "789",
+            ]
+            mock_read_checksum.return_value = (
+                "999",
+                "123",
+            )
+
+            result = tox_runner.detect_required_serializations(fail_fast=False)
+            self.assertEqual(result, ["custom"])
+
+    def test_main_fail_fast_resource_folder_checksum_inconsistent(self):
+        # Test main function fail-fast when resource folder checksums are inconsistent
         source_checksum = "123"
 
         with (
@@ -687,7 +809,7 @@ def test_main_fail_fast_resource_folder_binary_inconsistent(self):
 
             # Resource folder check raises RuntimeError
             mock_check_changes.side_effect = RuntimeError(
-                "INCONSISTENT RESOURCE FOLDER BINARY CHECKSUMS"
+                "INCONSISTENT RESOURCE FOLDER CHECKSUMS"
             )
 
             # Should propagate the RuntimeError
@@ -695,7 +817,7 @@ def test_main_fail_fast_resource_folder_binary_inconsistent(self):
                 tox_runner.main(fail_fast=True)
 
             self.assertEqual(
-                str(error.exception), "INCONSISTENT RESOURCE FOLDER BINARY CHECKSUMS"
+                str(error.exception), "INCONSISTENT RESOURCE FOLDER CHECKSUMS"
             )
             # Should not call subprocess
             mocked_subprocess.run.assert_not_called()
@@ -891,4 +1013,3 @@ def test_compute_and_compare_checksums_unchanged(self):
             
             self.assertFalse(result)
             mock_logger.info.assert_any_call('BINARY FILES UNCHANGED in folder: importer - Computed over 2 files - Checksum: same_checksum')
-
diff --git a/python-frontend/typeshed_serializer/tests/test_serializers.py b/python-frontend/typeshed_serializer/tests/test_serializers.py
index 42831654ac..96673c738b 100644
--- a/python-frontend/typeshed_serializer/tests/test_serializers.py
+++ b/python-frontend/typeshed_serializer/tests/test_serializers.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -73,8 +73,15 @@ def test_custom_stubs_serializer(typeshed_custom_stubs):
         )
         custom_stubs_serializer.serialize()
         assert custom_stubs_serializer.get_build_result.call_count == 1
-        # Not every files from "typeshed_custom_stubs" build are serialized, as some are builtins
-        assert symbols.save_module.call_count == 328
+        expected_serialized_modules = sum(
+            file != serializers.SONAR_CUSTOM_BASE_STUB_MODULE
+            and typeshed_custom_stubs.files.get(file).path.startswith(
+                custom_stubs_serializer.path
+            )
+            for file in typeshed_custom_stubs.files
+        )
+        assert symbols.save_module.call_count == expected_serialized_modules
+        assert expected_serialized_modules > 0
 
 
 def test_importer_serializer():
diff --git a/python-frontend/typeshed_serializer/tests/test_symbols.py b/python-frontend/typeshed_serializer/tests/test_symbols.py
index 5d3b64e926..80c4c3fab5 100644
--- a/python-frontend/typeshed_serializer/tests/test_symbols.py
+++ b/python-frontend/typeshed_serializer/tests/test_symbols.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/tests/test_symbols_merger.py b/python-frontend/typeshed_serializer/tests/test_symbols_merger.py
index 97931a9cd4..b76a6431b5 100644
--- a/python-frontend/typeshed_serializer/tests/test_symbols_merger.py
+++ b/python-frontend/typeshed_serializer/tests/test_symbols_merger.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/tests/test_typeshed_serializer.py b/python-frontend/typeshed_serializer/tests/test_typeshed_serializer.py
index a37d33e550..a6504a70c6 100644
--- a/python-frontend/typeshed_serializer/tests/test_typeshed_serializer.py
+++ b/python-frontend/typeshed_serializer/tests/test_typeshed_serializer.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/tests/utils/__init__.py b/python-frontend/typeshed_serializer/tests/utils/__init__.py
index 2a765941b7..2739b9a3ec 100644
--- a/python-frontend/typeshed_serializer/tests/utils/__init__.py
+++ b/python-frontend/typeshed_serializer/tests/utils/__init__.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/tests/utils/test_folder_manager.py b/python-frontend/typeshed_serializer/tests/utils/test_folder_manager.py
index 2bc159305f..d43f5ae63b 100644
--- a/python-frontend/typeshed_serializer/tests/utils/test_folder_manager.py
+++ b/python-frontend/typeshed_serializer/tests/utils/test_folder_manager.py
@@ -1,10 +1,10 @@
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource Sàrl
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# You can redistribute and/or modify this program under the terms of
+# the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/python-frontend/typeshed_serializer/tox.ini b/python-frontend/typeshed_serializer/tox.ini
index 0550d98180..1bfc1823a9 100644
--- a/python-frontend/typeshed_serializer/tox.ini
+++ b/python-frontend/typeshed_serializer/tox.ini
@@ -7,12 +7,17 @@ deps = -rrequirements.txt
 commands = python -m pytest --cov=serializer --cov=runners --cov-report xml:cov.xml --ignore=resources --cov-branch {posargs:tests/}
 
 [testenv:serialize]
+# pandas-stubs 2.2.3+ requires Python 3.10; the serializer env is 3.9.
+commands_pre =
+  python -m pip install pandas-stubs==2.2.3.241009 --ignore-requires-python
 commands =
   python -m utils.folder_manager
   python -m serializer.typeshed_serializer
 commands_post = python -c "from runners import tox_runner; tox_runner.update_all_checksums()"
 
 [testenv:selective-serialize]
+commands_pre =
+  python -m pip install pandas-stubs==2.2.3.241009 --ignore-requires-python
 commands =
   python -m utils.folder_manager {posargs}
   python -m serializer.typeshed_serializer {posargs}
diff --git a/renovate.json b/renovate.json
deleted file mode 100644
index 37f1181c33..0000000000
--- a/renovate.json
+++ /dev/null
@@ -1,48 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["github>SonarSource/renovate-config:languages-team"],
-  "enabledManagers": ["maven", "github-actions"],
-  "ignorePaths": ["python-frontend/typeshed_serializer/**"],
-
-  "packageRules": [
-    {
-      "matchManagers": ["maven"],
-      "matchPackageNames": ["*"],
-      "matchUpdateTypes": ["minor", "patch"],
-      "groupName": "all non-major dependencies",
-      "groupSlug": "all-minor-patch"
-    },
-    {
-      "matchPackageNames": [
-        "/sonar-plugin-api/",
-        "/org.sonarsource.sonarqube.*/"
-      ],
-      "groupName": "sonarqube",
-      "groupSlug": "sq"
-    },
-    {
-      "matchPackageNames": [
-        "com.google.protobuf:protobuf-java",
-        "com.google.protobuf:protoc"
-      ],
-      "groupName": "protobuf",
-      "groupSlug": "protobuf"
-    },
-    {
-      "matchPackageNames": [
-        "org.sonarsource.parent:parent",
-        "com.sonarsource.parent:parent"
-      ],
-      "groupName": "parent"
-    },
-    {
-      "matchPackageNames": ["/org.sonarsource.sonarlint.core.*/"],
-      "groupName": "SL core"
-    },
-    {
-      "matchDepTypes": ["action"],
-      "rollbackPrs": false,
-      "pinDigests": false
-    }
-  ]
-}
diff --git a/sonar-python-plugin/pom.xml b/sonar-python-plugin/pom.xml
index 4965331230..dc44fa2762 100644
--- a/sonar-python-plugin/pom.xml
+++ b/sonar-python-plugin/pom.xml
@@ -6,7 +6,7 @@
   
     org.sonarsource.python
     python
-    5.19-SNAPSHOT
+    5.30-SNAPSHOT
   
 
   sonar-python-plugin
@@ -37,12 +37,6 @@
       org.sonarsource.sonarlint.core
       sonarlint-plugin-api
     
-    
-      org.sonarsource.sonarqube
-      sonar-plugin-api-impl
-      ${sonar.version}
-      test
-    
     
       ${project.groupId}
       python-frontend
@@ -195,7 +189,7 @@
 
       
         maven-resources-plugin
-        3.4.0
+        3.5.0
         
           
             copy-main-license
diff --git a/sonar-python-plugin/src/main/java/org/sonar/plugins/python/PythonPlugin.java b/sonar-python-plugin/src/main/java/org/sonar/plugins/python/PythonPlugin.java
index e6f8739e88..da5fc0c85a 100644
--- a/sonar-python-plugin/src/main/java/org/sonar/plugins/python/PythonPlugin.java
+++ b/sonar-python-plugin/src/main/java/org/sonar/plugins/python/PythonPlugin.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/sonar-python-plugin/src/main/java/org/sonar/plugins/python/package-info.java b/sonar-python-plugin/src/main/java/org/sonar/plugins/python/package-info.java
index 4309be6908..f7731e1fc7 100644
--- a/sonar-python-plugin/src/main/java/org/sonar/plugins/python/package-info.java
+++ b/sonar-python-plugin/src/main/java/org/sonar/plugins/python/package-info.java
@@ -1,10 +1,10 @@
 /*
  * SonarQube Python Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
diff --git a/sonar-python-plugin/src/main/resources/licenses/THIRD_PARTY_LICENSES/xml-apis.xml-apis-LICENSE.txt b/sonar-python-plugin/src/main/resources/licenses/THIRD_PARTY_LICENSES/xml-apis.xml-apis-LICENSE.txt
deleted file mode 100644
index d645695673..0000000000
--- a/sonar-python-plugin/src/main/resources/licenses/THIRD_PARTY_LICENSES/xml-apis.xml-apis-LICENSE.txt
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.
diff --git a/sonarpedia.json b/sonarpedia.json
index d2c72f9bdf..c2576db557 100644
--- a/sonarpedia.json
+++ b/sonarpedia.json
@@ -3,7 +3,7 @@
   "languages": [
     "PY"
   ],
-  "latest-update": "2026-02-18T12:35:08.274727508Z",
+  "latest-update": "2026-08-07T06:02:02.110618Z",
   "options": {
     "no-language-in-filenames": true,
     "preserve-filenames": true
diff --git a/tools/validate_licenses.py b/tools/validate_licenses.py
index 5d53b86308..eb5fd48e60 100644
--- a/tools/validate_licenses.py
+++ b/tools/validate_licenses.py
@@ -2,11 +2,11 @@
 
 #
 # SonarQube Python Plugin
-# Copyright (C) 2011-2025 SonarSource SA
+# Copyright (C) SonarSource Sàrl
 # mailto:info AT sonarsource DOT com
 #
 # This program is free software; you can redistribute it and/or
-# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+# modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of